// ExtJS.js
//


Type.createNamespace('Ext');

////////////////////////////////////////////////////////////////////////////////
// Ext.ActionConfig

Ext.ActionConfig = function Ext_ActionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ActionConfig.prototype = {
    
    text: function Ext_ActionConfig$text(value) {
        /// <summary>
        /// The text to set for all components using this action (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    iconCls: function Ext_ActionConfig$iconCls(value) {
        /// <summary>
        /// The icon CSS class for all components using this action (defaults to ''). The class should supply a background image that will be used as the icon image.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    disabled: function Ext_ActionConfig$disabled(value) {
        /// <summary>
        /// True to disable all components using this action, false to enable them (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    hidden: function Ext_ActionConfig$hidden(value) {
        /// <summary>
        /// True to hide all components using this action, false to show them (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    handler: function Ext_ActionConfig$handler(value) {
        /// <summary>
        /// The function that will be invoked by each component tied to this action when the component's primary event is triggered (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_ActionConfig$scope(value) {
        /// <summary>
        /// The scope in which the {@link #handler} function will execute.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    custom: function Ext_ActionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ActionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ActionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.AjaxConfig

Ext.AjaxConfig = function Ext_AjaxConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.AjaxConfig.prototype = {
    
    url: function Ext_AjaxConfig$url(value) {
        /// <summary>
        /// (Optional) The default URL to be used for requests to the server. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    extraParams: function Ext_AjaxConfig$extraParams(value) {
        /// <summary>
        /// (Optional) An object containing properties which are used as extra parameters to each request made by this object. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['extraParams'] = value;
        return this;
    },
    
    defaultHeaders: function Ext_AjaxConfig$defaultHeaders(value) {
        /// <summary>
        /// (Optional) An object containing request headers which are added to each request made by this object. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['defaultHeaders'] = value;
        return this;
    },
    
    method: function Ext_AjaxConfig$method(value) {
        /// <summary>
        /// (Optional) The default HTTP method to be used for requests. (defaults to undefined; if not set, but {@link #request} params are present, POST will be used; otherwise, GET will be used.)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    timeout: function Ext_AjaxConfig$timeout(value) {
        /// <summary>
        /// (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    autoAbort: function Ext_AjaxConfig$autoAbort(value) {
        /// <summary>
        /// (Optional) Whether this request should abort any pending requests. (defaults to false) @type Boolean
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['autoAbort'] = value;
        return this;
    },
    
    disableCaching: function Ext_AjaxConfig$disableCaching(value) {
        /// <summary>
        /// (Optional) True to add a unique cache-buster param to GET requests. (defaults to true) @type Boolean
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['disableCaching'] = value;
        return this;
    },
    
    listeners: function Ext_AjaxConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_AjaxConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.AjaxConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_AjaxConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.BoxComponentConfig

Ext.BoxComponentConfig = function Ext_BoxComponentConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.BoxComponentConfig.prototype = {
    
    x: function Ext_BoxComponentConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_BoxComponentConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_BoxComponentConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_BoxComponentConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_BoxComponentConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_BoxComponentConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_BoxComponentConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_BoxComponentConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_BoxComponentConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_BoxComponentConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_BoxComponentConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_BoxComponentConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_BoxComponentConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_BoxComponentConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_BoxComponentConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_BoxComponentConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_BoxComponentConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_BoxComponentConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_BoxComponentConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_BoxComponentConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_BoxComponentConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_BoxComponentConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_BoxComponentConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_BoxComponentConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_BoxComponentConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_BoxComponentConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_BoxComponentConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.BoxComponentConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_BoxComponentConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.BoxComponentEvents

Ext.BoxComponentEvents = function Ext_BoxComponentEvents() {
}
Ext.BoxComponentEvents.get_resize = function Ext_BoxComponentEvents$get_resize() {
    /// <summary>
    /// Fires after the component is resized.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Number} adjWidth, {Number} adjHeight, {Number} rawWidth, {Number} rawHeight)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>adjWidth</b></term><description>The box-adjusted width that was set</description></item><item><term><b>adjHeight</b></term><description>The box-adjusted height that was set</description></item><item><term><b>rawWidth</b></term><description>The width that was originally specified</description></item><item><term><b>rawHeight</b></term><description>The height that was originally specified</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'resize';
}
Ext.BoxComponentEvents.get_move = function Ext_BoxComponentEvents$get_move() {
    /// <summary>
    /// Fires after the component is moved.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Number} x, {Number} y)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>x</b></term><description>The new x position</description></item><item><term><b>y</b></term><description>The new y position</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'move';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ButtonConfig

Ext.ButtonConfig = function Ext_ButtonConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ButtonConfig.prototype = {
    
    text: function Ext_ButtonConfig$text(value) {
        /// <summary>
        /// The button text
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    icon: function Ext_ButtonConfig$icon(value) {
        /// <summary>
        /// The path to an image to display in the button (the image will be set as the background-image
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    handler: function Ext_ButtonConfig$handler(value) {
        /// <summary>
        /// A function called when the button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_ButtonConfig$scope(value) {
        /// <summary>
        /// The scope of the handler
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    minWidth: function Ext_ButtonConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for this button (used to give a set of buttons a common width)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    tooltip: function Ext_ButtonConfig$tooltip(value) {
        /// <summary>
        /// {String/Object} The tooltip for the button - can be a string or QuickTips config object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    hidden: function Ext_ButtonConfig$hidden(value) {
        /// <summary>
        /// True to start hidden (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    disabled: function Ext_ButtonConfig$disabled(value) {
        /// <summary>
        /// True to start disabled (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    pressed: function Ext_ButtonConfig$pressed(value) {
        /// <summary>
        /// True to start pressed (only if enableToggle = true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['pressed'] = value;
        return this;
    },
    
    toggleGroup: function Ext_ButtonConfig$toggleGroup(value) {
        /// <summary>
        /// The group this toggle button is a member of (only 1 per group can be pressed, only
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['toggleGroup'] = value;
        return this;
    },
    
    repeat: function Ext_ButtonConfig$repeat(value) {
        /// <summary>
        /// {Boolean/Object} True to repeat fire the click event while the mouse is down. This can also be
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['repeat'] = value;
        return this;
    },
    
    tabIndex: function Ext_ButtonConfig$tabIndex(value) {
        /// <summary>
        /// Set a DOM tabIndex for this button (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    allowDepress: function Ext_ButtonConfig$allowDepress(value) {
        /// <summary>
        /// True to allow a pressed Button to be depressed (defaults to false). Only valid when {@link #enableToggle} is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['allowDepress'] = value;
        return this;
    },
    
    enableToggle: function Ext_ButtonConfig$enableToggle(value) {
        /// <summary>
        /// True to enable pressed/not pressed toggling (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['enableToggle'] = value;
        return this;
    },
    
    toggleHandler: function Ext_ButtonConfig$toggleHandler(value) {
        /// <summary>
        /// Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:<ul class="mdetail-params"><li><b>button</b> : Ext.Button<div class="sub-desc">this Button object</div></li><li><b>state</b> : Boolean<div class="sub-desc">The next state if the Button, true means pressed.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['toggleHandler'] = value;
        return this;
    },
    
    menu: function Ext_ButtonConfig$menu(value) {
        /// <summary>
        /// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    menuAlign: function Ext_ButtonConfig$menuAlign(value) {
        /// <summary>
        /// The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['menuAlign'] = value;
        return this;
    },
    
    iconCls: function Ext_ButtonConfig$iconCls(value) {
        /// <summary>
        /// A css class which sets a background image to be used as the icon for this button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    type: function Ext_ButtonConfig$type(value) {
        /// <summary>
        /// submit, reset or button - defaults to 'button'
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['type'] = value;
        return this;
    },
    
    clickEvent: function Ext_ButtonConfig$clickEvent(value) {
        /// <summary>
        /// The type of event to map to the button's event handler (defaults to 'click')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['clickEvent'] = value;
        return this;
    },
    
    handleMouseEvents: function Ext_ButtonConfig$handleMouseEvents(value) {
        /// <summary>
        /// False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['handleMouseEvents'] = value;
        return this;
    },
    
    tooltipType: function Ext_ButtonConfig$tooltipType(value) {
        /// <summary>
        /// The type of tooltip to use. Either "qtip" (default) for QuickTips or "title" for title attribute.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['tooltipType'] = value;
        return this;
    },
    
    template: function Ext_ButtonConfig$template(value) {
        /// <summary>
        /// (Optional) An {@link Ext.Template} with which to create the Button's main element. This Template must contain numeric substitution parameter 0 if it is to display the text property. Changing the template could require code modifications if required elements (e.g. a button) aren't present.
        /// </summary>
        /// <param name="value" type="Ext.Template">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['template'] = value;
        return this;
    },
    
    cls: function Ext_ButtonConfig$cls(value) {
        /// <summary>
        /// A CSS class string to apply to the button's main element.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    xtype: function Ext_ButtonConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ButtonConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ButtonConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_ButtonConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ButtonConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ButtonConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ButtonConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ButtonConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ButtonConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ButtonConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ButtonConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ButtonConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ButtonConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ButtonConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ButtonConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ButtonConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ButtonConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ButtonConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ButtonConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ButtonConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ButtonEvents

Ext.ButtonEvents = function Ext_ButtonEvents() {
}
Ext.ButtonEvents.get_click = function Ext_ButtonEvents$get_click() {
    /// <summary>
    /// Fires when this button is clicked
    /// <pre><code>
    /// USAGE: ({Button} objthis, {EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The click event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.ButtonEvents.get_toggle = function Ext_ButtonEvents$get_toggle() {
    /// <summary>
    /// Fires when the "pressed" state of this button changes (only if enableToggle = true)
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Boolean} pressed)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>pressed</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'toggle';
}
Ext.ButtonEvents.get_mouseover = function Ext_ButtonEvents$get_mouseover() {
    /// <summary>
    /// Fires when the mouse hovers over the button
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Event} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseover';
}
Ext.ButtonEvents.get_mouseout = function Ext_ButtonEvents$get_mouseout() {
    /// <summary>
    /// Fires when the mouse exits the button
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Event} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseout';
}
Ext.ButtonEvents.get_menushow = function Ext_ButtonEvents$get_menushow() {
    /// <summary>
    /// If this button has a menu, this event fires when it is shown
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Menu} menu)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>menu</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'menushow';
}
Ext.ButtonEvents.get_menuhide = function Ext_ButtonEvents$get_menuhide() {
    /// <summary>
    /// If this button has a menu, this event fires when it is hidden
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Menu} menu)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>menu</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'menuhide';
}
Ext.ButtonEvents.get_menutriggerover = function Ext_ButtonEvents$get_menutriggerover() {
    /// <summary>
    /// If this button has a menu, this event fires when the mouse enters the menu triggering element
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Menu} menu, {EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>menu</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'menutriggerover';
}
Ext.ButtonEvents.get_menutriggerout = function Ext_ButtonEvents$get_menutriggerout() {
    /// <summary>
    /// If this button has a menu, this event fires when the mouse leaves the menu triggering element
    /// <pre><code>
    /// USAGE: ({Button} objthis, {Menu} menu, {EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>menu</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'menutriggerout';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ColorPaletteConfig

Ext.ColorPaletteConfig = function Ext_ColorPaletteConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ColorPaletteConfig.prototype = {
    
    tpl: function Ext_ColorPaletteConfig$tpl(value) {
        /// <summary>
        /// An existing XTemplate instance to be used in place of the default template for rendering the component.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['tpl'] = value;
        return this;
    },
    
    itemCls: function Ext_ColorPaletteConfig$itemCls(value) {
        /// <summary>
        /// The CSS class to apply to the containing element (defaults to "x-color-palette")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    value: function Ext_ColorPaletteConfig$value(value) {
        /// <summary>
        /// The initial color to highlight (should be a valid 6-digit color hex code without the # symbol).  Note that the hex codes are case-sensitive.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    allowReselect: function Ext_ColorPaletteConfig$allowReselect(value) {
        /// <summary>
        /// If set to true then reselecting a color that is already selected fires the selection event
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['allowReselect'] = value;
        return this;
    },
    
    xtype: function Ext_ColorPaletteConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ColorPaletteConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ColorPaletteConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ColorPaletteConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ColorPaletteConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ColorPaletteConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ColorPaletteConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ColorPaletteConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ColorPaletteConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ColorPaletteConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ColorPaletteConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ColorPaletteConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ColorPaletteConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ColorPaletteConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ColorPaletteConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ColorPaletteConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ColorPaletteConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ColorPaletteConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ColorPaletteConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ColorPaletteConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ColorPaletteConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ColorPaletteEvents

Ext.ColorPaletteEvents = function Ext_ColorPaletteEvents() {
}
Ext.ColorPaletteEvents.get_select = function Ext_ColorPaletteEvents$get_select() {
    /// <summary>
    /// Fires when a color is selected
    /// <pre><code>
    /// USAGE: ({ColorPalette} objthis, {String} color)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>color</b></term><description>The 6-digit color hex code (without the # symbol)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'select';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ComponentConfig

Ext.ComponentConfig = function Ext_ComponentConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ComponentConfig.prototype = {
    
    xtype: function Ext_ComponentConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ComponentConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ComponentConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ComponentConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ComponentConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ComponentConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ComponentConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ComponentConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ComponentConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ComponentConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ComponentConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ComponentConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ComponentConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ComponentConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ComponentConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ComponentConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ComponentConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ComponentConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ComponentConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ComponentConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ComponentEvents

Ext.ComponentEvents = function Ext_ComponentEvents() {
}
Ext.ComponentEvents.get_disable = function Ext_ComponentEvents$get_disable() {
    /// <summary>
    /// Fires after the component is disabled.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'disable';
}
Ext.ComponentEvents.get_enable = function Ext_ComponentEvents$get_enable() {
    /// <summary>
    /// Fires after the component is enabled.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'enable';
}
Ext.ComponentEvents.get_beforeshow = function Ext_ComponentEvents$get_beforeshow() {
    /// <summary>
    /// Fires before the component is shown. Return false to stop the show.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeshow';
}
Ext.ComponentEvents.get_show = function Ext_ComponentEvents$get_show() {
    /// <summary>
    /// Fires after the component is shown.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'show';
}
Ext.ComponentEvents.get_beforehide = function Ext_ComponentEvents$get_beforehide() {
    /// <summary>
    /// Fires before the component is hidden. Return false to stop the hide.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforehide';
}
Ext.ComponentEvents.get_hide = function Ext_ComponentEvents$get_hide() {
    /// <summary>
    /// Fires after the component is hidden.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'hide';
}
Ext.ComponentEvents.get_beforerender = function Ext_ComponentEvents$get_beforerender() {
    /// <summary>
    /// Fires before the component is rendered. Return false to stop the render.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerender';
}
Ext.ComponentEvents.get_render = function Ext_ComponentEvents$get_render() {
    /// <summary>
    /// Fires after the component is rendered.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'render';
}
Ext.ComponentEvents.get_beforedestroy = function Ext_ComponentEvents$get_beforedestroy() {
    /// <summary>
    /// Fires before the component is destroyed. Return false to stop the destroy.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforedestroy';
}
Ext.ComponentEvents.get_destroy = function Ext_ComponentEvents$get_destroy() {
    /// <summary>
    /// Fires after the component is destroyed.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'destroy';
}
Ext.ComponentEvents.get_beforestaterestore = function Ext_ComponentEvents$get_beforestaterestore() {
    /// <summary>
    /// Fires before the state of the component is restored. Return false to stop the restore.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Object} state)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>state</b></term><description>The hash of state values</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforestaterestore';
}
Ext.ComponentEvents.get_staterestore = function Ext_ComponentEvents$get_staterestore() {
    /// <summary>
    /// Fires after the state of the component is restored.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Object} state)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>state</b></term><description>The hash of state values</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'staterestore';
}
Ext.ComponentEvents.get_beforestatesave = function Ext_ComponentEvents$get_beforestatesave() {
    /// <summary>
    /// Fires before the state of the component is saved to the configured state provider. Return false to stop the save.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Object} state)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>state</b></term><description>The hash of state values</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforestatesave';
}
Ext.ComponentEvents.get_statesave = function Ext_ComponentEvents$get_statesave() {
    /// <summary>
    /// Fires after the state of the component is saved to the configured state provider.
    /// <pre><code>
    /// USAGE: ({Ext.Component} objthis, {Object} state)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>state</b></term><description>The hash of state values</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'statesave';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ComponentMgrConfig

Ext.ComponentMgrConfig = function Ext_ComponentMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ComponentMgrConfig.prototype = {
    
    custom: function Ext_ComponentMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ComponentMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ComponentMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.CompositeElementConfig

Ext.CompositeElementConfig = function Ext_CompositeElementConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.CompositeElementConfig.prototype = {
    
    custom: function Ext_CompositeElementConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CompositeElementConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_CompositeElementConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.CompositeElementLiteConfig

Ext.CompositeElementLiteConfig = function Ext_CompositeElementLiteConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.CompositeElementLiteConfig.prototype = {
    
    custom: function Ext_CompositeElementLiteConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CompositeElementLiteConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_CompositeElementLiteConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ContainerConfig

Ext.ContainerConfig = function Ext_ContainerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ContainerConfig.prototype = {
    
    defaultType: function Ext_ContainerConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_ContainerConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_ContainerConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_ContainerConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_ContainerConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_ContainerConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_ContainerConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_ContainerConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ContainerConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ContainerConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ContainerConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ContainerConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_ContainerConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_ContainerConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ContainerConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ContainerConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ContainerConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ContainerConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ContainerConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ContainerConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ContainerConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ContainerConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ContainerConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ContainerConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ContainerConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ContainerConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ContainerConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ContainerConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ContainerConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ContainerConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ContainerConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ContainerConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ContainerConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ContainerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ContainerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ContainerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ContainerEvents

Ext.ContainerEvents = function Ext_ContainerEvents() {
}
Ext.ContainerEvents.get_afterlayout = function Ext_ContainerEvents$get_afterlayout() {
    /// <summary>
    /// Fires when the components in this container are arranged by the associated layout manager.
    /// <pre><code>
    /// USAGE: ({Ext.Container} objthis, {ContainerLayout} layout)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>layout</b></term><description>The ContainerLayout implementation for this container</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'afterlayout';
}
Ext.ContainerEvents.get_beforeadd = function Ext_ContainerEvents$get_beforeadd() {
    /// <summary>
    /// Fires before any {@link Ext.Component} is added or inserted into the container.
    /// A handler can return false to cancel the add.
    /// <pre><code>
    /// USAGE: ({Ext.Container} objthis, {Ext.Component} component, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>component</b></term><description>The component being added</description></item><item><term><b>index</b></term><description>The index at which the component will be added to the container's items collection</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeadd';
}
Ext.ContainerEvents.get_beforeremove = function Ext_ContainerEvents$get_beforeremove() {
    /// <summary>
    /// Fires before any {@link Ext.Component} is removed from the container.  A handler can return
    /// false to cancel the remove.
    /// <pre><code>
    /// USAGE: ({Ext.Container} objthis, {Ext.Component} component)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>component</b></term><description>The component being removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeremove';
}
Ext.ContainerEvents.get_add = function Ext_ContainerEvents$get_add() {
    /// <summary>
    /// Fires after any {@link Ext.Component} is added or inserted into the container.
    /// <pre><code>
    /// USAGE: ({Ext.Container} objthis, {Ext.Component} component, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>component</b></term><description>The component that was added</description></item><item><term><b>index</b></term><description>The index at which the component was added to the container's items collection</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'add';
}
Ext.ContainerEvents.get_remove = function Ext_ContainerEvents$get_remove() {
    /// <summary>
    /// Fires after any {@link Ext.Component} is removed from the container.
    /// <pre><code>
    /// USAGE: ({Ext.Container} objthis, {Ext.Component} component)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>component</b></term><description>The component that was removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.CycleButtonConfig

Ext.CycleButtonConfig = function Ext_CycleButtonConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.CycleButtonConfig.prototype = {
    
    items: function Ext_CycleButtonConfig$items(value) {
        /// <summary>
        /// An array of {@link Ext.menu.CheckItem} <b>config</b> objects to be used when creating the button's menu items (e.g., {text:'Foo', iconCls:'foo-icon'})
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    showText: function Ext_CycleButtonConfig$showText(value) {
        /// <summary>
        /// True to display the active item's text as the button text (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['showText'] = value;
        return this;
    },
    
    prependText: function Ext_CycleButtonConfig$prependText(value) {
        /// <summary>
        /// A static string to prepend before the active item's text when displayed as the button's text (only applies when showText = true, defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['prependText'] = value;
        return this;
    },
    
    changeHandler: function Ext_CycleButtonConfig$changeHandler(value) {
        /// <summary>
        /// A callback function that will be invoked each time the active menu item in the button's menu has changed.  If this callback is not supplied, the SplitButton will instead fire the {@link #change} event on active item change.  The changeHandler function will be called with the following argument list: (SplitButton this, Ext.menu.CheckItem item)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['changeHandler'] = value;
        return this;
    },
    
    forceIcon: function Ext_CycleButtonConfig$forceIcon(value) {
        /// <summary>
        /// A css class which sets an image to be used as the static icon for this button.  This icon will always be displayed regardless of which item is selected in the dropdown list.  This overrides the default behavior of changing the button's icon to match the selected item's icon on change.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['forceIcon'] = value;
        return this;
    },
    
    arrowHandler: function Ext_CycleButtonConfig$arrowHandler(value) {
        /// <summary>
        /// A function called when the arrow button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['arrowHandler'] = value;
        return this;
    },
    
    arrowTooltip: function Ext_CycleButtonConfig$arrowTooltip(value) {
        /// <summary>
        /// The title attribute of the arrow
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['arrowTooltip'] = value;
        return this;
    },
    
    text: function Ext_CycleButtonConfig$text(value) {
        /// <summary>
        /// The button text
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    icon: function Ext_CycleButtonConfig$icon(value) {
        /// <summary>
        /// The path to an image to display in the button (the image will be set as the background-image
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    handler: function Ext_CycleButtonConfig$handler(value) {
        /// <summary>
        /// A function called when the button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_CycleButtonConfig$scope(value) {
        /// <summary>
        /// The scope of the handler
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    minWidth: function Ext_CycleButtonConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for this button (used to give a set of buttons a common width)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    tooltip: function Ext_CycleButtonConfig$tooltip(value) {
        /// <summary>
        /// {String/Object} The tooltip for the button - can be a string or QuickTips config object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    hidden: function Ext_CycleButtonConfig$hidden(value) {
        /// <summary>
        /// True to start hidden (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    disabled: function Ext_CycleButtonConfig$disabled(value) {
        /// <summary>
        /// True to start disabled (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    pressed: function Ext_CycleButtonConfig$pressed(value) {
        /// <summary>
        /// True to start pressed (only if enableToggle = true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['pressed'] = value;
        return this;
    },
    
    toggleGroup: function Ext_CycleButtonConfig$toggleGroup(value) {
        /// <summary>
        /// The group this toggle button is a member of (only 1 per group can be pressed, only
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['toggleGroup'] = value;
        return this;
    },
    
    repeat: function Ext_CycleButtonConfig$repeat(value) {
        /// <summary>
        /// {Boolean/Object} True to repeat fire the click event while the mouse is down. This can also be
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['repeat'] = value;
        return this;
    },
    
    tabIndex: function Ext_CycleButtonConfig$tabIndex(value) {
        /// <summary>
        /// Set a DOM tabIndex for this button (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    allowDepress: function Ext_CycleButtonConfig$allowDepress(value) {
        /// <summary>
        /// True to allow a pressed Button to be depressed (defaults to false). Only valid when {@link #enableToggle} is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['allowDepress'] = value;
        return this;
    },
    
    enableToggle: function Ext_CycleButtonConfig$enableToggle(value) {
        /// <summary>
        /// True to enable pressed/not pressed toggling (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['enableToggle'] = value;
        return this;
    },
    
    toggleHandler: function Ext_CycleButtonConfig$toggleHandler(value) {
        /// <summary>
        /// Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:<ul class="mdetail-params"><li><b>button</b> : Ext.Button<div class="sub-desc">this Button object</div></li><li><b>state</b> : Boolean<div class="sub-desc">The next state if the Button, true means pressed.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['toggleHandler'] = value;
        return this;
    },
    
    menu: function Ext_CycleButtonConfig$menu(value) {
        /// <summary>
        /// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    menuAlign: function Ext_CycleButtonConfig$menuAlign(value) {
        /// <summary>
        /// The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['menuAlign'] = value;
        return this;
    },
    
    iconCls: function Ext_CycleButtonConfig$iconCls(value) {
        /// <summary>
        /// A css class which sets a background image to be used as the icon for this button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    type: function Ext_CycleButtonConfig$type(value) {
        /// <summary>
        /// submit, reset or button - defaults to 'button'
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['type'] = value;
        return this;
    },
    
    clickEvent: function Ext_CycleButtonConfig$clickEvent(value) {
        /// <summary>
        /// The type of event to map to the button's event handler (defaults to 'click')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['clickEvent'] = value;
        return this;
    },
    
    handleMouseEvents: function Ext_CycleButtonConfig$handleMouseEvents(value) {
        /// <summary>
        /// False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['handleMouseEvents'] = value;
        return this;
    },
    
    tooltipType: function Ext_CycleButtonConfig$tooltipType(value) {
        /// <summary>
        /// The type of tooltip to use. Either "qtip" (default) for QuickTips or "title" for title attribute.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['tooltipType'] = value;
        return this;
    },
    
    template: function Ext_CycleButtonConfig$template(value) {
        /// <summary>
        /// (Optional) An {@link Ext.Template} with which to create the Button's main element. This Template must contain numeric substitution parameter 0 if it is to display the text property. Changing the template could require code modifications if required elements (e.g. a button) aren't present.
        /// </summary>
        /// <param name="value" type="Ext.Template">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['template'] = value;
        return this;
    },
    
    cls: function Ext_CycleButtonConfig$cls(value) {
        /// <summary>
        /// A CSS class string to apply to the button's main element.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    xtype: function Ext_CycleButtonConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_CycleButtonConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_CycleButtonConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_CycleButtonConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_CycleButtonConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_CycleButtonConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_CycleButtonConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_CycleButtonConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_CycleButtonConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_CycleButtonConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_CycleButtonConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_CycleButtonConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_CycleButtonConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_CycleButtonConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_CycleButtonConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_CycleButtonConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_CycleButtonConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_CycleButtonConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.CycleButtonConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_CycleButtonConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.CycleButtonEvents

Ext.CycleButtonEvents = function Ext_CycleButtonEvents() {
}
Ext.CycleButtonEvents.get_change = function Ext_CycleButtonEvents$get_change() {
    /// <summary>
    /// Fires after the button's active menu item has changed.  Note that if a {@link #changeHandler} function
    /// is set on this CycleButton, it will be called instead on active item change and this change event will
    /// not be fired.
    /// <pre><code>
    /// USAGE: ({Ext.CycleButton} objthis, {Ext.menu.CheckItem} item)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>item</b></term><description>The menu item that was selected</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'change';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DataViewConfig

Ext.DataViewConfig = function Ext_DataViewConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.DataViewConfig.prototype = {
    
    tpl: function Ext_DataViewConfig$tpl(value) {
        /// <summary>
        /// {String/Array}  The HTML fragment or an array of fragments that will make up the template used by this DataView.  This should be specified in the same format expected by the constructor of {@link Ext.XTemplate}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['tpl'] = value;
        return this;
    },
    
    store: function Ext_DataViewConfig$store(value) {
        /// <summary>
        /// The {@link Ext.data.Store} to bind this DataView to.
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    itemSelector: function Ext_DataViewConfig$itemSelector(value) {
        /// <summary>
        /// <b>This is a required setting</b>. A simple CSS selector (e.g. div.some-class or span:first-child) that will be used to determine what nodes this DataView will be working with.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['itemSelector'] = value;
        return this;
    },
    
    multiSelect: function Ext_DataViewConfig$multiSelect(value) {
        /// <summary>
        /// True to allow selection of more than one item at a time, false to allow selection of only a single item at a time or no selection at all, depending on the value of {@link #singleSelect} (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['multiSelect'] = value;
        return this;
    },
    
    singleSelect: function Ext_DataViewConfig$singleSelect(value) {
        /// <summary>
        /// True to allow selection of exactly one item at a time, false to allow no selection at all (defaults to false). Note that if {@link #multiSelect} = true, this value will be ignored.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['singleSelect'] = value;
        return this;
    },
    
    simpleSelect: function Ext_DataViewConfig$simpleSelect(value) {
        /// <summary>
        /// True to enable multiselection by clicking on multiple items without requiring the user to hold Shift or Ctrl, false to force the user to hold Ctrl or Shift to select more than on item (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['simpleSelect'] = value;
        return this;
    },
    
    overClass: function Ext_DataViewConfig$overClass(value) {
        /// <summary>
        /// A CSS class to apply to each item in the view on mouseover (defaults to undefined).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['overClass'] = value;
        return this;
    },
    
    loadingText: function Ext_DataViewConfig$loadingText(value) {
        /// <summary>
        /// A string to display during data load operations (defaults to undefined).  If specified, this text will be displayed in a loading div and the view's contents will be cleared while loading, otherwise the view's contents will continue to display normally until the new data is loaded and the contents are replaced.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['loadingText'] = value;
        return this;
    },
    
    selectedClass: function Ext_DataViewConfig$selectedClass(value) {
        /// <summary>
        /// A CSS class to apply to each selected item in the view (defaults to 'x-view-selected').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['selectedClass'] = value;
        return this;
    },
    
    emptyText: function Ext_DataViewConfig$emptyText(value) {
        /// <summary>
        /// The text to display in the view when there is no data to display (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    deferEmptyText: function Ext_DataViewConfig$deferEmptyText(value) {
        /// <summary>
        /// True to defer emptyText being applied until the store's first load
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['deferEmptyText'] = value;
        return this;
    },
    
    x: function Ext_DataViewConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_DataViewConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_DataViewConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_DataViewConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_DataViewConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_DataViewConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_DataViewConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_DataViewConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_DataViewConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_DataViewConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_DataViewConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_DataViewConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_DataViewConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_DataViewConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_DataViewConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_DataViewConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_DataViewConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_DataViewConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_DataViewConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_DataViewConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_DataViewConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_DataViewConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_DataViewConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_DataViewConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_DataViewConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_DataViewConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_DataViewConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DataViewConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_DataViewConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DataViewEvents

Ext.DataViewEvents = function Ext_DataViewEvents() {
}
Ext.DataViewEvents.get_beforeclick = function Ext_DataViewEvents$get_beforeclick() {
    /// <summary>
    /// Fires before a click is processed. Returns false to cancel the default action.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Number} index, {HTMLElement} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>index</b></term><description>The index of the target node</description></item><item><term><b>node</b></term><description>The target node</description></item><item><term><b>e</b></term><description>The raw event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeclick';
}
Ext.DataViewEvents.get_click = function Ext_DataViewEvents$get_click() {
    /// <summary>
    /// Fires when a template node is clicked.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Number} index, {HTMLElement} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>index</b></term><description>The index of the target node</description></item><item><term><b>node</b></term><description>The target node</description></item><item><term><b>e</b></term><description>The raw event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.DataViewEvents.get_containerclick = function Ext_DataViewEvents$get_containerclick() {
    /// <summary>
    /// Fires when a click occurs and it is not on a template node.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The raw event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'containerclick';
}
Ext.DataViewEvents.get_dblclick = function Ext_DataViewEvents$get_dblclick() {
    /// <summary>
    /// Fires when a template node is double clicked.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Number} index, {HTMLElement} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>index</b></term><description>The index of the target node</description></item><item><term><b>node</b></term><description>The target node</description></item><item><term><b>e</b></term><description>The raw event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dblclick';
}
Ext.DataViewEvents.get_contextmenu = function Ext_DataViewEvents$get_contextmenu() {
    /// <summary>
    /// Fires when a template node is right clicked.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Number} index, {HTMLElement} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>index</b></term><description>The index of the target node</description></item><item><term><b>node</b></term><description>The target node</description></item><item><term><b>e</b></term><description>The raw event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'contextmenu';
}
Ext.DataViewEvents.get_selectionchange = function Ext_DataViewEvents$get_selectionchange() {
    /// <summary>
    /// Fires when the selected nodes change.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {Array} selections)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>selections</b></term><description>Array of the selected nodes</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'selectionchange';
}
Ext.DataViewEvents.get_beforeselect = function Ext_DataViewEvents$get_beforeselect() {
    /// <summary>
    /// Fires before a selection is made. If any handlers return false, the selection is cancelled.
    /// <pre><code>
    /// USAGE: ({Ext.DataView} objthis, {HTMLElement} node, {Array} selections)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description>The node to be selected</description></item><item><term><b>selections</b></term><description>Array of currently selected nodes</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeselect';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DatePickerConfig

Ext.DatePickerConfig = function Ext_DatePickerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.DatePickerConfig.prototype = {
    
    todayText: function Ext_DatePickerConfig$todayText(value) {
        /// <summary>
        /// The text to display on the button that selects the current date (defaults to "Today")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['todayText'] = value;
        return this;
    },
    
    okText: function Ext_DatePickerConfig$okText(value) {
        /// <summary>
        /// The text to display on the ok button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['okText'] = value;
        return this;
    },
    
    cancelText: function Ext_DatePickerConfig$cancelText(value) {
        /// <summary>
        /// The text to display on the cancel button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['cancelText'] = value;
        return this;
    },
    
    todayTip: function Ext_DatePickerConfig$todayTip(value) {
        /// <summary>
        /// The tooltip to display for the button that selects the current date (defaults to "{current date} (Spacebar)")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['todayTip'] = value;
        return this;
    },
    
    minDate: function Ext_DatePickerConfig$minDate(value) {
        /// <summary>
        /// Minimum allowable date (JavaScript date object, defaults to null)
        /// </summary>
        /// <param name="value" type="Date">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['minDate'] = value;
        return this;
    },
    
    maxDate: function Ext_DatePickerConfig$maxDate(value) {
        /// <summary>
        /// Maximum allowable date (JavaScript date object, defaults to null)
        /// </summary>
        /// <param name="value" type="Date">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['maxDate'] = value;
        return this;
    },
    
    minText: function Ext_DatePickerConfig$minText(value) {
        /// <summary>
        /// The error text to display if the minDate validation fails (defaults to "This date is before the minimum date")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['minText'] = value;
        return this;
    },
    
    maxText: function Ext_DatePickerConfig$maxText(value) {
        /// <summary>
        /// The error text to display if the maxDate validation fails (defaults to "This date is after the maximum date")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['maxText'] = value;
        return this;
    },
    
    format: function Ext_DatePickerConfig$format(value) {
        /// <summary>
        /// The default date format string which can be overriden for localization support.  The format must be valid according to {@link Date#parseDate} (defaults to 'm/d/y').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['format'] = value;
        return this;
    },
    
    disabledDays: function Ext_DatePickerConfig$disabledDays(value) {
        /// <summary>
        /// An array of days to disable, 0-based. For example, [0, 6] disables Sunday and Saturday (defaults to null).
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['disabledDays'] = value;
        return this;
    },
    
    disabledDaysText: function Ext_DatePickerConfig$disabledDaysText(value) {
        /// <summary>
        /// The tooltip to display when the date falls on a disabled day (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['disabledDaysText'] = value;
        return this;
    },
    
    disabledDatesRE: function Ext_DatePickerConfig$disabledDatesRE(value) {
        /// <summary>
        /// JavaScript regular expression used to disable a pattern of dates (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['disabledDatesRE'] = value;
        return this;
    },
    
    disabledDatesText: function Ext_DatePickerConfig$disabledDatesText(value) {
        /// <summary>
        /// The tooltip text to display when the date falls on a disabled date (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['disabledDatesText'] = value;
        return this;
    },
    
    constrainToViewport: function Ext_DatePickerConfig$constrainToViewport(value) {
        /// <summary>
        /// True to constrain the date picker to the viewport (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['constrainToViewport'] = value;
        return this;
    },
    
    monthNames: function Ext_DatePickerConfig$monthNames(value) {
        /// <summary>
        /// An array of textual month names which can be overriden for localization support (defaults to Date.monthNames)
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['monthNames'] = value;
        return this;
    },
    
    dayNames: function Ext_DatePickerConfig$dayNames(value) {
        /// <summary>
        /// An array of textual day names which can be overriden for localization support (defaults to Date.dayNames)
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['dayNames'] = value;
        return this;
    },
    
    nextText: function Ext_DatePickerConfig$nextText(value) {
        /// <summary>
        /// The next month navigation button tooltip (defaults to 'Next Month (Control+Right)')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['nextText'] = value;
        return this;
    },
    
    prevText: function Ext_DatePickerConfig$prevText(value) {
        /// <summary>
        /// The previous month navigation button tooltip (defaults to 'Previous Month (Control+Left)')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['prevText'] = value;
        return this;
    },
    
    monthYearText: function Ext_DatePickerConfig$monthYearText(value) {
        /// <summary>
        /// The header month selector tooltip (defaults to 'Choose a month (Control+Up/Down to move years)')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['monthYearText'] = value;
        return this;
    },
    
    startDay: function Ext_DatePickerConfig$startDay(value) {
        /// <summary>
        /// Day index at which the week should begin, 0-based (defaults to 0, which is Sunday)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['startDay'] = value;
        return this;
    },
    
    xtype: function Ext_DatePickerConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_DatePickerConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_DatePickerConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_DatePickerConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_DatePickerConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_DatePickerConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_DatePickerConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_DatePickerConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_DatePickerConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_DatePickerConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_DatePickerConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_DatePickerConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_DatePickerConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_DatePickerConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_DatePickerConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_DatePickerConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_DatePickerConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_DatePickerConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_DatePickerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DatePickerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_DatePickerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DatePickerEvents

Ext.DatePickerEvents = function Ext_DatePickerEvents() {
}
Ext.DatePickerEvents.get_select = function Ext_DatePickerEvents$get_select() {
    /// <summary>
    /// Fires when a date is selected
    /// <pre><code>
    /// USAGE: ({DatePicker} objthis, {Date} date)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>date</b></term><description>The selected date</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'select';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DomHelperConfig

Ext.DomHelperConfig = function Ext_DomHelperConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.DomHelperConfig.prototype = {
    
    custom: function Ext_DomHelperConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DomHelperConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_DomHelperConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.DomQueryConfig

Ext.DomQueryConfig = function Ext_DomQueryConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.DomQueryConfig.prototype = {
    
    custom: function Ext_DomQueryConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.DomQueryConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_DomQueryConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.EditorConfig

Ext.EditorConfig = function Ext_EditorConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.EditorConfig.prototype = {
    
    autoSize: function Ext_EditorConfig$autoSize(value) {
        /// <summary>
        /// {Boolean/String}  True for the editor to automatically adopt the size of the underlying field, "width" to adopt the width only, or "height" to adopt the height only (defaults to false)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['autoSize'] = value;
        return this;
    },
    
    revertInvalid: function Ext_EditorConfig$revertInvalid(value) {
        /// <summary>
        /// True to automatically revert the field value and cancel the edit when the user completes an edit and the field validation fails (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['revertInvalid'] = value;
        return this;
    },
    
    ignoreNoChange: function Ext_EditorConfig$ignoreNoChange(value) {
        /// <summary>
        /// True to skip the the edit completion process (no save, no events fired) if the user completes an edit and the value has not changed (defaults to false).  Applies only to string values - edits for other data types will never be ignored.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['ignoreNoChange'] = value;
        return this;
    },
    
    hideEl: function Ext_EditorConfig$hideEl(value) {
        /// <summary>
        /// False to keep the bound element visible while the editor is displayed (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['hideEl'] = value;
        return this;
    },
    
    value: function Ext_EditorConfig$value(value) {
        /// <summary>
        /// The data value of the underlying field (defaults to "")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    alignment: function Ext_EditorConfig$alignment(value) {
        /// <summary>
        /// The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "c-c?").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['alignment'] = value;
        return this;
    },
    
    shadow: function Ext_EditorConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "frame")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    constrain: function Ext_EditorConfig$constrain(value) {
        /// <summary>
        /// True to constrain the editor to the viewport
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['constrain'] = value;
        return this;
    },
    
    swallowKeys: function Ext_EditorConfig$swallowKeys(value) {
        /// <summary>
        /// Handle the keydown/keypress events so they don't propagate (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['swallowKeys'] = value;
        return this;
    },
    
    completeOnEnter: function Ext_EditorConfig$completeOnEnter(value) {
        /// <summary>
        /// True to complete the edit when the enter key is pressed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['completeOnEnter'] = value;
        return this;
    },
    
    cancelOnEsc: function Ext_EditorConfig$cancelOnEsc(value) {
        /// <summary>
        /// True to cancel the edit when the escape key is pressed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['cancelOnEsc'] = value;
        return this;
    },
    
    updateEl: function Ext_EditorConfig$updateEl(value) {
        /// <summary>
        /// True to update the innerHTML of the bound element when the update completes (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['updateEl'] = value;
        return this;
    },
    
    xtype: function Ext_EditorConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_EditorConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_EditorConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_EditorConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_EditorConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_EditorConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_EditorConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_EditorConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_EditorConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_EditorConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_EditorConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_EditorConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_EditorConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_EditorConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_EditorConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_EditorConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_EditorConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_EditorConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_EditorConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EditorConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_EditorConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.EditorEvents

Ext.EditorEvents = function Ext_EditorEvents() {
}
Ext.EditorEvents.get_beforestartedit = function Ext_EditorEvents$get_beforestartedit() {
    /// <summary>
    /// Fires when editing is initiated, but before the value changes.  Editing can be canceled by returning
    /// false from the handler of this event.
    /// <pre><code>
    /// USAGE: ({Editor} objthis, {Ext.Element} boundEl, {Mixed} value)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>boundEl</b></term><description>The underlying element bound to this editor</description></item><item><term><b>value</b></term><description>The field value being set</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforestartedit';
}
Ext.EditorEvents.get_startedit = function Ext_EditorEvents$get_startedit() {
    /// <summary>
    /// Fires when this editor is displayed
    /// <pre><code>
    /// USAGE: ({Ext.Element} boundEl, {Mixed} value)
    /// </code></pre><list type="bullet"><item><term><b>boundEl</b></term><description>The underlying element bound to this editor</description></item><item><term><b>value</b></term><description>The starting field value</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'startedit';
}
Ext.EditorEvents.get_beforecomplete = function Ext_EditorEvents$get_beforecomplete() {
    /// <summary>
    /// Fires after a change has been made to the field, but before the change is reflected in the underlying
    /// field.  Saving the change to the field can be canceled by returning false from the handler of this event.
    /// Note that if the value has not changed and ignoreNoChange = true, the editing will still end but this
    /// event will not fire since no edit actually occurred.
    /// <pre><code>
    /// USAGE: ({Editor} objthis, {Mixed} value, {Mixed} startValue)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>value</b></term><description>The current field value</description></item><item><term><b>startValue</b></term><description>The original field value</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecomplete';
}
Ext.EditorEvents.get_complete = function Ext_EditorEvents$get_complete() {
    /// <summary>
    /// Fires after editing is complete and any changed value has been written to the underlying field.
    /// <pre><code>
    /// USAGE: ({Editor} objthis, {Mixed} value, {Mixed} startValue)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>value</b></term><description>The current field value</description></item><item><term><b>startValue</b></term><description>The original field value</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'complete';
}
Ext.EditorEvents.get_specialkey = function Ext_EditorEvents$get_specialkey() {
    /// <summary>
    /// Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed.  You can check
    /// {@link Ext.EventObject#getKey} to determine which key was pressed.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'specialkey';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ElementConfig

Ext.ElementConfig = function Ext_ElementConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ElementConfig.prototype = {
    
    custom: function Ext_ElementConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ElementConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ElementConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.EventManagerConfig

Ext.EventManagerConfig = function Ext_EventManagerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.EventManagerConfig.prototype = {
    
    custom: function Ext_EventManagerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EventManagerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_EventManagerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.EventObjectConfig

Ext.EventObjectConfig = function Ext_EventObjectConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.EventObjectConfig.prototype = {
    
    custom: function Ext_EventObjectConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.EventObjectConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_EventObjectConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ExtConfig

Ext.ExtConfig = function Ext_ExtConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ExtConfig.prototype = {
    
    custom: function Ext_ExtConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ExtConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ExtConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.FxConfig

Ext.FxConfig = function Ext_FxConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.FxConfig.prototype = {
    
    stopFx: function Ext_FxConfig$stopFx(value) {
        /// <summary>
        /// @class Ext.Fx <p>A class to provide basic animation and visual effects support.  <b>Note:</b> This class is automatically applied to the {@link Ext.Element} interface when included, so all effects calls should be performed via Element. Conversely, since the effects are not actually defined in Element, Ext.Fx <b>must</b> be included in order for the Element effects to work.</p><br /><p>It is important to note that although the Fx methods and many non-Fx Element methods support "method chaining" in that they return the Element object itself as the method return value, it is not always possible to mix the two in a single method chain.  The Fx methods use an internal effects queue so that each effect can be properly timed and sequenced. Non-Fx methods, on the other hand, have no such internal queueing and will always execute immediately.  For this reason, while it may be possible to mix certain Fx and non-Fx method calls in a single chain, it may not always provide the expected results and should be done with care.</p><br /><p>Motion effects support 8-way anchoring, meaning that you can choose one of 8 different anchor points on the Element that will serve as either the start or end point of the animation.  Following are all of the supported anchor positions:</p><pre> Value  Description -----  ----------------------------- tl     The top left corner t      The center of the top edge tr     The top right corner l      The center of the left edge r      The center of the right edge bl     The bottom left corner b      The center of the bottom edge br     The bottom right corner </pre><b>Although some Fx methods accept specific custom config parameters, the ones shown in the Config Options section below are common options that can be passed to any Fx method.</b>A function called when the effect is finished.  Note that effects are queued internally by the Fx class, so do not need to use the callback parameter to specify another effect -- effects can simply be chained together and called in sequence (e.g., el.slideIn().highlight();).  The callback is intended for any additional code that should run once a particular effect has completed.The scope of the effect functionA valid Easing value for the effectA css class to apply after the effectThe length of time (in seconds) that the effect should lastWhether the Element should be removed from the DOM and destroyed after the effect finishesWhether to use the <i>display</i> CSS property instead of <i>visibility</i> when hiding Elements (only applies to effects that end with the element being visually hidden, ignored otherwise)A style specification string, e.g. "width:100px", or an object in the form {width:"100px"}, or a function which returns such a specification that will be applied to the Element after the effect finishesWhether the effect should block other effects from queueing while it runsWhether to allow subsequently-queued effects to run at the same time as the current effect, or to ensure that they run in sequenceWhether subsequent effects should be stopped and removed after the current effect finishes
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.FxConfig"></returns>
        this.o['stopFx'] = value;
        return this;
    },
    
    custom: function Ext_FxConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.FxConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_FxConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.KeyMapConfig

Ext.KeyMapConfig = function Ext_KeyMapConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.KeyMapConfig.prototype = {
    
    custom: function Ext_KeyMapConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.KeyMapConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_KeyMapConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.KeyNavConfig

Ext.KeyNavConfig = function Ext_KeyNavConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.KeyNavConfig.prototype = {
    
    disabled: function Ext_KeyNavConfig$disabled(value) {
        /// <summary>
        /// True to disable this KeyNav instance (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.KeyNavConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    defaultEventAction: function Ext_KeyNavConfig$defaultEventAction(value) {
        /// <summary>
        /// The method to call on the {@link Ext.EventObject} after this KeyNav intercepts a key.  Valid values are {@link Ext.EventObject#stopEvent}, {@link Ext.EventObject#preventDefault} and {@link Ext.EventObject#stopPropagation} (defaults to 'stopEvent')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.KeyNavConfig"></returns>
        this.o['defaultEventAction'] = value;
        return this;
    },
    
    forceKeyDown: function Ext_KeyNavConfig$forceKeyDown(value) {
        /// <summary>
        /// Handle the keydown event instead of keypress (defaults to false).  KeyNav automatically does this for IE since IE does not propagate special keys on keypress, but setting this to true will force other browsers to also handle keydown instead of keypress.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.KeyNavConfig"></returns>
        this.o['forceKeyDown'] = value;
        return this;
    },
    
    custom: function Ext_KeyNavConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.KeyNavConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_KeyNavConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.LayerConfig

Ext.LayerConfig = function Ext_LayerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.LayerConfig.prototype = {
    
    shim: function Ext_LayerConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    shadow: function Ext_LayerConfig$shadow(value) {
        /// <summary>
        /// {String/Boolean} True to create a shadow element with default class "x-layer-shadow", or
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    dh: function Ext_LayerConfig$dh(value) {
        /// <summary>
        /// DomHelper object config to create element with (defaults to {tag: "div", cls: "x-layer"}).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['dh'] = value;
        return this;
    },
    
    constrain: function Ext_LayerConfig$constrain(value) {
        /// <summary>
        /// False to disable constrain to viewport (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['constrain'] = value;
        return this;
    },
    
    cls: function Ext_LayerConfig$cls(value) {
        /// <summary>
        /// CSS class to add to the element
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    zindex: function Ext_LayerConfig$zindex(value) {
        /// <summary>
        /// Starting z-index (defaults to 11000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['zindex'] = value;
        return this;
    },
    
    shadowOffset: function Ext_LayerConfig$shadowOffset(value) {
        /// <summary>
        /// Number of pixels to offset the shadow (defaults to 3)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    custom: function Ext_LayerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.LayerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_LayerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.LoadMaskConfig

Ext.LoadMaskConfig = function Ext_LoadMaskConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.LoadMaskConfig.prototype = {
    
    store: function Ext_LoadMaskConfig$store(value) {
        /// <summary>
        /// Optional Store to which the mask is bound. The mask is displayed when a load request is issued, and hidden on either load sucess, or load fail.
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.LoadMaskConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    removeMask: function Ext_LoadMaskConfig$removeMask(value) {
        /// <summary>
        /// True to create a single-use mask that is automatically destroyed after loading (useful for page loads), False to persist the mask element reference for multiple uses (e.g., for paged data widgets).  Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.LoadMaskConfig"></returns>
        this.o['removeMask'] = value;
        return this;
    },
    
    msg: function Ext_LoadMaskConfig$msg(value) {
        /// <summary>
        /// The text to display in a centered loading message box (defaults to 'Loading...')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.LoadMaskConfig"></returns>
        this.o['msg'] = value;
        return this;
    },
    
    msgCls: function Ext_LoadMaskConfig$msgCls(value) {
        /// <summary>
        /// The CSS class to apply to the loading message element (defaults to "x-mask-loading")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.LoadMaskConfig"></returns>
        this.o['msgCls'] = value;
        return this;
    },
    
    custom: function Ext_LoadMaskConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.LoadMaskConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_LoadMaskConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.MessageBoxConfig

Ext.MessageBoxConfig = function Ext_MessageBoxConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.MessageBoxConfig.prototype = {
    
    custom: function Ext_MessageBoxConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.MessageBoxConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_MessageBoxConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.PagingToolbarConfig

Ext.PagingToolbarConfig = function Ext_PagingToolbarConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.PagingToolbarConfig.prototype = {
    
    store: function Ext_PagingToolbarConfig$store(value) {
        /// <summary>
        /// The {@link Ext.data.Store} the paging toolbar should use as its data source (required).
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    displayInfo: function Ext_PagingToolbarConfig$displayInfo(value) {
        /// <summary>
        /// True to display the displayMsg (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['displayInfo'] = value;
        return this;
    },
    
    pageSize: function Ext_PagingToolbarConfig$pageSize(value) {
        /// <summary>
        /// The number of records to display per page (defaults to 20)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['pageSize'] = value;
        return this;
    },
    
    displayMsg: function Ext_PagingToolbarConfig$displayMsg(value) {
        /// <summary>
        /// The paging status message to display (defaults to "Displaying {0} - {1} of {2}").  Note that this string is formatted using the braced numbers 0-2 as tokens that are replaced by the values for start, end and total respectively. These tokens should be preserved when overriding this string if showing those values is desired.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['displayMsg'] = value;
        return this;
    },
    
    emptyMsg: function Ext_PagingToolbarConfig$emptyMsg(value) {
        /// <summary>
        /// The message to display when no records are found (defaults to "No data to display")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['emptyMsg'] = value;
        return this;
    },
    
    x: function Ext_PagingToolbarConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_PagingToolbarConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_PagingToolbarConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_PagingToolbarConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_PagingToolbarConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_PagingToolbarConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_PagingToolbarConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_PagingToolbarConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_PagingToolbarConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_PagingToolbarConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_PagingToolbarConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_PagingToolbarConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_PagingToolbarConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_PagingToolbarConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_PagingToolbarConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_PagingToolbarConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_PagingToolbarConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_PagingToolbarConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_PagingToolbarConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_PagingToolbarConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_PagingToolbarConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_PagingToolbarConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_PagingToolbarConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_PagingToolbarConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_PagingToolbarConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_PagingToolbarConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    items: function Ext_PagingToolbarConfig$items(value) {
        /// <param name="value" type="Array" elementType="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    custom: function Ext_PagingToolbarConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PagingToolbarConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_PagingToolbarConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.PanelConfig

Ext.PanelConfig = function Ext_PanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.PanelConfig.prototype = {
    
    applyTo: function Ext_PanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_PanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_PanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_PanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_PanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_PanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_PanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_PanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_PanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_PanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_PanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_PanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_PanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_PanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_PanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_PanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_PanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_PanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_PanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_PanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_PanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_PanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_PanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_PanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_PanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_PanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_PanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_PanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_PanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_PanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_PanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_PanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_PanelConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_PanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_PanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_PanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_PanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_PanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_PanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_PanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_PanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_PanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_PanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_PanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_PanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_PanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_PanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_PanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_PanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_PanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_PanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_PanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_PanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_PanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_PanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_PanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_PanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_PanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_PanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_PanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_PanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_PanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_PanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_PanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_PanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_PanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_PanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_PanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_PanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_PanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.PanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_PanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.PanelEvents

Ext.PanelEvents = function Ext_PanelEvents() {
}
Ext.PanelEvents.get_bodyresize = function Ext_PanelEvents$get_bodyresize() {
    /// <summary>
    /// Fires after the Panel has been resized.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p, {Number} width, {Number} height)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>the Panel which has been resized.</description></item><item><term><b>width</b></term><description>The Panel's new width.</description></item><item><term><b>height</b></term><description>The Panel's new height.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'bodyresize';
}
Ext.PanelEvents.get_titlechange = function Ext_PanelEvents$get_titlechange() {
    /// <summary>
    /// Fires after the Panel title has been set or changed.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p, {String} The)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>the Panel which has had its title changed.</description></item><item><term><b>The</b></term><description>new title.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'titlechange';
}
Ext.PanelEvents.get_collapse = function Ext_PanelEvents$get_collapse() {
    /// <summary>
    /// Fires after the Panel has been collapsed.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>the Panel that has been collapsed.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'collapse';
}
Ext.PanelEvents.get_expand = function Ext_PanelEvents$get_expand() {
    /// <summary>
    /// Fires after the Panel has been expanded.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel that has been expanded.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'expand';
}
Ext.PanelEvents.get_beforecollapse = function Ext_PanelEvents$get_beforecollapse() {
    /// <summary>
    /// Fires before the Panel is collapsed.  A handler can return false to cancel the collapse.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p, {Boolean} animate)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>the Panel being collapsed.</description></item><item><term><b>animate</b></term><description>True if the collapse is animated, else false.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecollapse';
}
Ext.PanelEvents.get_beforeexpand = function Ext_PanelEvents$get_beforeexpand() {
    /// <summary>
    /// Fires before the Panel is expanded.  A handler can return false to cancel the expand.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p, {Boolean} animate)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel being expanded.</description></item><item><term><b>animate</b></term><description>True if the expand is animated, else false.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeexpand';
}
Ext.PanelEvents.get_beforeclose = function Ext_PanelEvents$get_beforeclose() {
    /// <summary>
    /// Fires before the Panel is closed.  Note that Panels do not directly support being closed, but some
    /// Panel subclasses do (like {@link Ext.Window}).  This event only applies to such subclasses.
    /// A handler can return false to cancel the close.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel being closed.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeclose';
}
Ext.PanelEvents.get_close = function Ext_PanelEvents$get_close() {
    /// <summary>
    /// Fires after the Panel is closed.  Note that Panels do not directly support being closed, but some
    /// Panel subclasses do (like {@link Ext.Window}).
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel that has been closed.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'close';
}
Ext.PanelEvents.get_activate = function Ext_PanelEvents$get_activate() {
    /// <summary>
    /// Fires after the Panel has been visually activated.
    /// Note that Panels do not directly support being activated, but some Panel subclasses
    /// do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
    /// activate and deactivate events under the control of the TabPanel.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel that has been activated.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'activate';
}
Ext.PanelEvents.get_deactivate = function Ext_PanelEvents$get_deactivate() {
    /// <summary>
    /// Fires after the Panel has been visually deactivated.
    /// Note that Panels do not directly support being deactivated, but some Panel subclasses
    /// do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
    /// activate and deactivate events under the control of the TabPanel.
    /// <pre><code>
    /// USAGE: ({Ext.Panel} p)
    /// </code></pre><list type="bullet"><item><term><b>p</b></term><description>The Panel that has been deactivated.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'deactivate';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ProgressBarConfig

Ext.ProgressBarConfig = function Ext_ProgressBarConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ProgressBarConfig.prototype = {
    
    id: function Ext_ProgressBarConfig$id(value) {
        /// <summary>
        /// @class Ext.ProgressBar @extends Ext.BoxComponent <p>An updateable progress bar component.  The progress bar supports two different modes: manual and automatic.</p><p>In manual mode, you are responsible for showing, updating (via {@link #updateProgress}) and clearing the progress bar as needed from your own code.  This method is most appropriate when you want to show progress throughout an operation that has predictable points of interest at which you can update the control.</p><p>In automatic mode, you simply call {@link #wait} and let the progress bar run indefinitely, only clearing it once the operation is complete.  You can optionally have the progress bar wait for a specific amount of time and then clear itself.  Automatic mode is most appropriate for timed operations or asymchronous operations in which you have no need for indicating intermediate progress.</p>A floating point value between 0 and 1 (e.g., .5, defaults to 0)The progress bar text (defaults to '')The element to render the progress text to (defaults to the progress bar's internal text element)The progress bar element's id (defaults to an auto-generated id)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    baseCls: function Ext_ProgressBarConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to the progress bar's wrapper element (defaults to 'x-progress')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    x: function Ext_ProgressBarConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ProgressBarConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ProgressBarConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ProgressBarConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ProgressBarConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_ProgressBarConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_ProgressBarConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ProgressBarConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ProgressBarConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    autoEl: function Ext_ProgressBarConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ProgressBarConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ProgressBarConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ProgressBarConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ProgressBarConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ProgressBarConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ProgressBarConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ProgressBarConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ProgressBarConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ProgressBarConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ProgressBarConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ProgressBarConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ProgressBarConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ProgressBarConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ProgressBarConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ProgressBarConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ProgressBarConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ProgressBarConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ProgressBarConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ProgressBarEvents

Ext.ProgressBarEvents = function Ext_ProgressBarEvents() {
}
Ext.ProgressBarEvents.get_update = function Ext_ProgressBarEvents$get_update() {
    /// <summary>
    /// Fires after each update interval
    /// <pre><code>
    /// USAGE: ({Ext.ProgressBar} objthis, {Number} The, {String} The2)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>The</b></term><description>current progress value</description></item><item><term><b>The2</b></term><description>current progress text</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'update';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.QuickTipConfig

Ext.QuickTipConfig = function Ext_QuickTipConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.QuickTipConfig.prototype = {
    
    target: function Ext_QuickTipConfig$target(value) {
        /// <summary>
        /// The target HTMLElement, Ext.Element or id to associate with this quicktip (defaults to the document).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['target'] = value;
        return this;
    },
    
    interceptTitles: function Ext_QuickTipConfig$interceptTitles(value) {
        /// <summary>
        /// True to automatically use the element's DOM title value if available (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['interceptTitles'] = value;
        return this;
    },
    
    autoHide: function Ext_QuickTipConfig$autoHide(value) {
        /// <summary>
        /// True to automatically hide the tooltip after the mouse exits the target element or after the {@link #dismissDelay} has expired if set (defaults to true).  If {@link closable} = true a close tool button will be rendered into the tooltip header.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoHide'] = value;
        return this;
    },
    
    showDelay: function Ext_QuickTipConfig$showDelay(value) {
        /// <summary>
        /// Delay in milliseconds before the tooltip displays after the mouse enters the target element (defaults to 500)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['showDelay'] = value;
        return this;
    },
    
    hideDelay: function Ext_QuickTipConfig$hideDelay(value) {
        /// <summary>
        /// Delay in milliseconds after the mouse exits the target element but before the tooltip actually hides (defaults to 200).  Set to 0 for the tooltip to hide immediately.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    dismissDelay: function Ext_QuickTipConfig$dismissDelay(value) {
        /// <summary>
        /// Delay in milliseconds before the tooltip automatically hides (defaults to 5000). To disable automatic hiding, set dismissDelay = 0.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['dismissDelay'] = value;
        return this;
    },
    
    mouseOffset: function Ext_QuickTipConfig$mouseOffset(value) {
        /// <summary>
        /// An XY offset from the mouse position where the tooltip should be shown (defaults to [15,18]).
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['mouseOffset'] = value;
        return this;
    },
    
    trackMouse: function Ext_QuickTipConfig$trackMouse(value) {
        /// <summary>
        /// True to have the tooltip follow the mouse as it moves over the target element (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['trackMouse'] = value;
        return this;
    },
    
    closable: function Ext_QuickTipConfig$closable(value) {
        /// <summary>
        /// True to render a close tool button into the tooltip header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['closable'] = value;
        return this;
    },
    
    width: function Ext_QuickTipConfig$width(value) {
        /// <summary>
        /// Width in pixels of the tip (defaults to auto).  Width will be ignored if it exceeds the bounds of {@link #minWidth} or {@link #maxWidth}.  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    minWidth: function Ext_QuickTipConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the tip in pixels (defaults to 40).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    maxWidth: function Ext_QuickTipConfig$maxWidth(value) {
        /// <summary>
        /// The maximum width of the tip in pixels (defaults to 300).  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['maxWidth'] = value;
        return this;
    },
    
    shadow: function Ext_QuickTipConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    defaultAlign: function Ext_QuickTipConfig$defaultAlign(value) {
        /// <summary>
        /// <b>Experimental</b>. The default {@link Ext.Element#alignTo} anchor position value for this tip relative to its element of origin (defaults to "tl-bl?").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    applyTo: function Ext_QuickTipConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_QuickTipConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_QuickTipConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_QuickTipConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_QuickTipConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_QuickTipConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_QuickTipConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_QuickTipConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_QuickTipConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_QuickTipConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_QuickTipConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_QuickTipConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_QuickTipConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_QuickTipConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_QuickTipConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_QuickTipConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_QuickTipConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_QuickTipConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_QuickTipConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadowOffset: function Ext_QuickTipConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_QuickTipConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_QuickTipConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_QuickTipConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_QuickTipConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_QuickTipConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_QuickTipConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_QuickTipConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_QuickTipConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_QuickTipConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_QuickTipConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_QuickTipConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_QuickTipConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_QuickTipConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_QuickTipConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_QuickTipConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_QuickTipConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_QuickTipConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_QuickTipConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_QuickTipConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_QuickTipConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_QuickTipConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_QuickTipConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_QuickTipConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_QuickTipConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_QuickTipConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_QuickTipConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_QuickTipConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_QuickTipConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    autoHeight: function Ext_QuickTipConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_QuickTipConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_QuickTipConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_QuickTipConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_QuickTipConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_QuickTipConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_QuickTipConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_QuickTipConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_QuickTipConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_QuickTipConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_QuickTipConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_QuickTipConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_QuickTipConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_QuickTipConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_QuickTipConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_QuickTipConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_QuickTipConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_QuickTipConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_QuickTipConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_QuickTipConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_QuickTipConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.QuickTipsConfig

Ext.QuickTipsConfig = function Ext_QuickTipsConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.QuickTipsConfig.prototype = {
    
    custom: function Ext_QuickTipsConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.QuickTipsConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_QuickTipsConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ResizableConfig

Ext.ResizableConfig = function Ext_ResizableConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ResizableConfig.prototype = {
    
    resizeChild: function Ext_ResizableConfig$resizeChild(value) {
        /// <summary>
        /// {Boolean/String/Element} True to resize the first child, or id/element to resize (defaults to false)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['resizeChild'] = value;
        return this;
    },
    
    adjustments: function Ext_ResizableConfig$adjustments(value) {
        /// <summary>
        /// {Array/String} String "auto" or an array [width, height] with values to be <b>added</b> to the
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['adjustments'] = value;
        return this;
    },
    
    minWidth: function Ext_ResizableConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for the element (defaults to 5)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    minHeight: function Ext_ResizableConfig$minHeight(value) {
        /// <summary>
        /// The minimum height for the element (defaults to 5)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    maxWidth: function Ext_ResizableConfig$maxWidth(value) {
        /// <summary>
        /// The maximum width for the element (defaults to 10000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['maxWidth'] = value;
        return this;
    },
    
    maxHeight: function Ext_ResizableConfig$maxHeight(value) {
        /// <summary>
        /// The maximum height for the element (defaults to 10000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    enabled: function Ext_ResizableConfig$enabled(value) {
        /// <summary>
        /// False to disable resizing (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['enabled'] = value;
        return this;
    },
    
    wrap: function Ext_ResizableConfig$wrap(value) {
        /// <summary>
        /// True to wrap an element with a div if needed (required for textareas and images, defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['wrap'] = value;
        return this;
    },
    
    width: function Ext_ResizableConfig$width(value) {
        /// <summary>
        /// The width of the element in pixels (defaults to null)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    height: function Ext_ResizableConfig$height(value) {
        /// <summary>
        /// The height of the element in pixels (defaults to null)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    animate: function Ext_ResizableConfig$animate(value) {
        /// <summary>
        /// True to animate the resize (not compatible with dynamic sizing, defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['animate'] = value;
        return this;
    },
    
    duration: function Ext_ResizableConfig$duration(value) {
        /// <summary>
        /// Animation duration if animate = true (defaults to .35)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['duration'] = value;
        return this;
    },
    
    dynamic: function Ext_ResizableConfig$dynamic(value) {
        /// <summary>
        /// True to resize the element while dragging instead of using a proxy (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['dynamic'] = value;
        return this;
    },
    
    handles: function Ext_ResizableConfig$handles(value) {
        /// <summary>
        /// String consisting of the resize handles to display (defaults to undefined)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['handles'] = value;
        return this;
    },
    
    multiDirectional: function Ext_ResizableConfig$multiDirectional(value) {
        /// <summary>
        /// <b>Deprecated</b>.  The old style of adding multi-direction resize handles, deprecated
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['multiDirectional'] = value;
        return this;
    },
    
    disableTrackOver: function Ext_ResizableConfig$disableTrackOver(value) {
        /// <summary>
        /// True to disable mouse tracking. This is only applied at config time. (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['disableTrackOver'] = value;
        return this;
    },
    
    easing: function Ext_ResizableConfig$easing(value) {
        /// <summary>
        /// Animation easing if animate = true (defaults to 'easingOutStrong')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['easing'] = value;
        return this;
    },
    
    widthIncrement: function Ext_ResizableConfig$widthIncrement(value) {
        /// <summary>
        /// The increment to snap the width resize in pixels (dynamic must be true, defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['widthIncrement'] = value;
        return this;
    },
    
    heightIncrement: function Ext_ResizableConfig$heightIncrement(value) {
        /// <summary>
        /// The increment to snap the height resize in pixels (dynamic must be true, defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['heightIncrement'] = value;
        return this;
    },
    
    pinned: function Ext_ResizableConfig$pinned(value) {
        /// <summary>
        /// True to ensure that the resize handles are always visible, false to display them only when the
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['pinned'] = value;
        return this;
    },
    
    preserveRatio: function Ext_ResizableConfig$preserveRatio(value) {
        /// <summary>
        /// True to preserve the original ratio between height and width during resize (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['preserveRatio'] = value;
        return this;
    },
    
    transparent: function Ext_ResizableConfig$transparent(value) {
        /// <summary>
        /// True for transparent handles. This is only applied at config time. (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['transparent'] = value;
        return this;
    },
    
    minX: function Ext_ResizableConfig$minX(value) {
        /// <summary>
        /// The minimum allowed page X for the element (only used for west resizing, defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['minX'] = value;
        return this;
    },
    
    minY: function Ext_ResizableConfig$minY(value) {
        /// <summary>
        /// The minimum allowed page Y for the element (only used for north resizing, defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['minY'] = value;
        return this;
    },
    
    draggable: function Ext_ResizableConfig$draggable(value) {
        /// <summary>
        /// Convenience to initialize drag drop (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    constrainTo: function Ext_ResizableConfig$constrainTo(value) {
        /// <summary>
        /// Constrain the resize to a particular element
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['constrainTo'] = value;
        return this;
    },
    
    resizeRegion: function Ext_ResizableConfig$resizeRegion(value) {
        /// <summary>
        /// Constrain the resize to a particular region
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['resizeRegion'] = value;
        return this;
    },
    
    listeners: function Ext_ResizableConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ResizableConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ResizableConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ResizableConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ResizableEvents

Ext.ResizableEvents = function Ext_ResizableEvents() {
}
Ext.ResizableEvents.get_beforeresize = function Ext_ResizableEvents$get_beforeresize() {
    /// <summary>
    /// Fired before resize is allowed. Set enabled to false to cancel resize.
    /// <pre><code>
    /// USAGE: ({Ext.Resizable} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The mousedown event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeresize';
}
Ext.ResizableEvents.get_resize = function Ext_ResizableEvents$get_resize() {
    /// <summary>
    /// Fired after a resize.
    /// <pre><code>
    /// USAGE: ({Ext.Resizable} objthis, {Number} width, {Number} height, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>width</b></term><description>The new width</description></item><item><term><b>height</b></term><description>The new height</description></item><item><term><b>e</b></term><description>The mouseup event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'resize';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ShadowConfig

Ext.ShadowConfig = function Ext_ShadowConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ShadowConfig.prototype = {
    
    mode: function Ext_ShadowConfig$mode(value) {
        /// <summary>
        /// The shadow display mode.  Supports the following options:<br /> sides: Shadow displays on both sides and bottom only<br /> frame: Shadow displays equally on all four sides<br /> drop: Traditional bottom-right drop shadow (default)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ShadowConfig"></returns>
        this.o['mode'] = value;
        return this;
    },
    
    offset: function Ext_ShadowConfig$offset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow from the element (defaults to 4)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ShadowConfig"></returns>
        this.o['offset'] = value;
        return this;
    },
    
    custom: function Ext_ShadowConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ShadowConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ShadowConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SliderConfig

Ext.SliderConfig = function Ext_SliderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.SliderConfig.prototype = {
    
    value: function Ext_SliderConfig$value(value) {
        /// <summary>
        /// The value to initialize the slider with. Defaults to minValue.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    vertical: function Ext_SliderConfig$vertical(value) {
        /// <summary>
        /// Orient the Slider vertically rather than horizontally, defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['vertical'] = value;
        return this;
    },
    
    minValue: function Ext_SliderConfig$minValue(value) {
        /// <summary>
        /// The minimum value for the Slider. Defaults to 0.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['minValue'] = value;
        return this;
    },
    
    maxValue: function Ext_SliderConfig$maxValue(value) {
        /// <summary>
        /// The maximum value for the Slider. Defaults to 100.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['maxValue'] = value;
        return this;
    },
    
    keyIncrement: function Ext_SliderConfig$keyIncrement(value) {
        /// <summary>
        /// How many units to change the Slider when adjusting with keyboard navigation. Defaults to 1. If the increment config is larger, it will be used instead.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['keyIncrement'] = value;
        return this;
    },
    
    increment: function Ext_SliderConfig$increment(value) {
        /// <summary>
        /// How many units to change the slider when adjusting by drag and drop. Use this option to enable 'snapping'.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['increment'] = value;
        return this;
    },
    
    clickToChange: function Ext_SliderConfig$clickToChange(value) {
        /// <summary>
        /// Determines whether or not clicking on the Slider axis will change the slider. Defaults to true
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['clickToChange'] = value;
        return this;
    },
    
    animate: function Ext_SliderConfig$animate(value) {
        /// <summary>
        /// Turn on or off animation. Defaults to true
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['animate'] = value;
        return this;
    },
    
    x: function Ext_SliderConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_SliderConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_SliderConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_SliderConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_SliderConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_SliderConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_SliderConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_SliderConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_SliderConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_SliderConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_SliderConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_SliderConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_SliderConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_SliderConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_SliderConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_SliderConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_SliderConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_SliderConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_SliderConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_SliderConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_SliderConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_SliderConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_SliderConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_SliderConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_SliderConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_SliderConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_SliderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SliderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_SliderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SliderEvents

Ext.SliderEvents = function Ext_SliderEvents() {
}
Ext.SliderEvents.get_beforechange = function Ext_SliderEvents$get_beforechange() {
    /// <summary>
    /// Fires before the slider value is changed. By returning false from an event handler,
    /// you can cancel the event and prevent the slider from changing.
    /// <pre><code>
    /// USAGE: ({Ext.Slider} slider, {Number} newValue, {Number} oldValue)
    /// </code></pre><list type="bullet"><item><term><b>slider</b></term><description>The slider</description></item><item><term><b>newValue</b></term><description>The new value which the slider is being changed to.</description></item><item><term><b>oldValue</b></term><description>The old value which the slider was previously.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforechange';
}
Ext.SliderEvents.get_change = function Ext_SliderEvents$get_change() {
    /// <summary>
    /// Fires when the slider value is changed.
    /// <pre><code>
    /// USAGE: ({Ext.Slider} slider, {Number} newValue)
    /// </code></pre><list type="bullet"><item><term><b>slider</b></term><description>The slider</description></item><item><term><b>newValue</b></term><description>The new value which the slider has been changed to.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'change';
}
Ext.SliderEvents.get_dragstart = function Ext_SliderEvents$get_dragstart() {
    /// <summary>
    /// Fires after a drag operation has started.
    /// <pre><code>
    /// USAGE: ({Ext.Slider} slider, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>slider</b></term><description>The slider</description></item><item><term><b>e</b></term><description>The event fired from Ext.dd.DragTracker</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dragstart';
}
Ext.SliderEvents.get_drag = function Ext_SliderEvents$get_drag() {
    /// <summary>
    /// Fires continuously during the drag operation while the mouse is moving.
    /// <pre><code>
    /// USAGE: ({Ext.Slider} slider, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>slider</b></term><description>The slider</description></item><item><term><b>e</b></term><description>The event fired from Ext.dd.DragTracker</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'drag';
}
Ext.SliderEvents.get_dragend = function Ext_SliderEvents$get_dragend() {
    /// <summary>
    /// Fires after the drag operation has completed.
    /// <pre><code>
    /// USAGE: ({Ext.Slider} slider, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>slider</b></term><description>The slider</description></item><item><term><b>e</b></term><description>The event fired from Ext.dd.DragTracker</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dragend';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SplitBarConfig

Ext.SplitBarConfig = function Ext_SplitBarConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.SplitBarConfig.prototype = {
    
    listeners: function Ext_SplitBarConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitBarConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_SplitBarConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitBarConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_SplitBarConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SplitBarEvents

Ext.SplitBarEvents = function Ext_SplitBarEvents() {
}
Ext.SplitBarEvents.get_resize = function Ext_SplitBarEvents$get_resize() {
    /// <summary>
    /// Fires when the splitter is moved (alias for {@link #event-moved})
    /// <pre><code>
    /// USAGE: ({Ext.SplitBar} objthis, {Number} newSize)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>newSize</b></term><description>the new width or height</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'resize';
}
Ext.SplitBarEvents.get_moved = function Ext_SplitBarEvents$get_moved() {
    /// <summary>
    /// Fires when the splitter is moved
    /// <pre><code>
    /// USAGE: ({Ext.SplitBar} objthis, {Number} newSize)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>newSize</b></term><description>the new width or height</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'moved';
}
Ext.SplitBarEvents.get_beforeresize = function Ext_SplitBarEvents$get_beforeresize() {
    /// <summary>
    /// Fires before the splitter is dragged
    /// <pre><code>
    /// USAGE: ({Ext.SplitBar} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeresize';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SplitButtonConfig

Ext.SplitButtonConfig = function Ext_SplitButtonConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.SplitButtonConfig.prototype = {
    
    arrowHandler: function Ext_SplitButtonConfig$arrowHandler(value) {
        /// <summary>
        /// A function called when the arrow button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['arrowHandler'] = value;
        return this;
    },
    
    arrowTooltip: function Ext_SplitButtonConfig$arrowTooltip(value) {
        /// <summary>
        /// The title attribute of the arrow
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['arrowTooltip'] = value;
        return this;
    },
    
    text: function Ext_SplitButtonConfig$text(value) {
        /// <summary>
        /// The button text
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    icon: function Ext_SplitButtonConfig$icon(value) {
        /// <summary>
        /// The path to an image to display in the button (the image will be set as the background-image
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    handler: function Ext_SplitButtonConfig$handler(value) {
        /// <summary>
        /// A function called when the button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_SplitButtonConfig$scope(value) {
        /// <summary>
        /// The scope of the handler
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    minWidth: function Ext_SplitButtonConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for this button (used to give a set of buttons a common width)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    tooltip: function Ext_SplitButtonConfig$tooltip(value) {
        /// <summary>
        /// {String/Object} The tooltip for the button - can be a string or QuickTips config object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    hidden: function Ext_SplitButtonConfig$hidden(value) {
        /// <summary>
        /// True to start hidden (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    disabled: function Ext_SplitButtonConfig$disabled(value) {
        /// <summary>
        /// True to start disabled (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    pressed: function Ext_SplitButtonConfig$pressed(value) {
        /// <summary>
        /// True to start pressed (only if enableToggle = true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['pressed'] = value;
        return this;
    },
    
    toggleGroup: function Ext_SplitButtonConfig$toggleGroup(value) {
        /// <summary>
        /// The group this toggle button is a member of (only 1 per group can be pressed, only
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['toggleGroup'] = value;
        return this;
    },
    
    repeat: function Ext_SplitButtonConfig$repeat(value) {
        /// <summary>
        /// {Boolean/Object} True to repeat fire the click event while the mouse is down. This can also be
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['repeat'] = value;
        return this;
    },
    
    tabIndex: function Ext_SplitButtonConfig$tabIndex(value) {
        /// <summary>
        /// Set a DOM tabIndex for this button (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    allowDepress: function Ext_SplitButtonConfig$allowDepress(value) {
        /// <summary>
        /// True to allow a pressed Button to be depressed (defaults to false). Only valid when {@link #enableToggle} is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['allowDepress'] = value;
        return this;
    },
    
    enableToggle: function Ext_SplitButtonConfig$enableToggle(value) {
        /// <summary>
        /// True to enable pressed/not pressed toggling (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['enableToggle'] = value;
        return this;
    },
    
    toggleHandler: function Ext_SplitButtonConfig$toggleHandler(value) {
        /// <summary>
        /// Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:<ul class="mdetail-params"><li><b>button</b> : Ext.Button<div class="sub-desc">this Button object</div></li><li><b>state</b> : Boolean<div class="sub-desc">The next state if the Button, true means pressed.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['toggleHandler'] = value;
        return this;
    },
    
    menu: function Ext_SplitButtonConfig$menu(value) {
        /// <summary>
        /// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    menuAlign: function Ext_SplitButtonConfig$menuAlign(value) {
        /// <summary>
        /// The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['menuAlign'] = value;
        return this;
    },
    
    iconCls: function Ext_SplitButtonConfig$iconCls(value) {
        /// <summary>
        /// A css class which sets a background image to be used as the icon for this button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    type: function Ext_SplitButtonConfig$type(value) {
        /// <summary>
        /// submit, reset or button - defaults to 'button'
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['type'] = value;
        return this;
    },
    
    clickEvent: function Ext_SplitButtonConfig$clickEvent(value) {
        /// <summary>
        /// The type of event to map to the button's event handler (defaults to 'click')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['clickEvent'] = value;
        return this;
    },
    
    handleMouseEvents: function Ext_SplitButtonConfig$handleMouseEvents(value) {
        /// <summary>
        /// False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['handleMouseEvents'] = value;
        return this;
    },
    
    tooltipType: function Ext_SplitButtonConfig$tooltipType(value) {
        /// <summary>
        /// The type of tooltip to use. Either "qtip" (default) for QuickTips or "title" for title attribute.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['tooltipType'] = value;
        return this;
    },
    
    template: function Ext_SplitButtonConfig$template(value) {
        /// <summary>
        /// (Optional) An {@link Ext.Template} with which to create the Button's main element. This Template must contain numeric substitution parameter 0 if it is to display the text property. Changing the template could require code modifications if required elements (e.g. a button) aren't present.
        /// </summary>
        /// <param name="value" type="Ext.Template">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['template'] = value;
        return this;
    },
    
    cls: function Ext_SplitButtonConfig$cls(value) {
        /// <summary>
        /// A CSS class string to apply to the button's main element.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    xtype: function Ext_SplitButtonConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_SplitButtonConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_SplitButtonConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_SplitButtonConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_SplitButtonConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_SplitButtonConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_SplitButtonConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_SplitButtonConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_SplitButtonConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_SplitButtonConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_SplitButtonConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_SplitButtonConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_SplitButtonConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_SplitButtonConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_SplitButtonConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_SplitButtonConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_SplitButtonConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_SplitButtonConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitButtonConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_SplitButtonConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SplitButtonEvents

Ext.SplitButtonEvents = function Ext_SplitButtonEvents() {
}
Ext.SplitButtonEvents.get_arrowclick = function Ext_SplitButtonEvents$get_arrowclick() {
    /// <summary>
    /// Fires when this button's arrow is clicked
    /// <pre><code>
    /// USAGE: ({MenuButton} objthis, {EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The click event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'arrowclick';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.StatusBarConfig

Ext.StatusBarConfig = function Ext_StatusBarConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.StatusBarConfig.prototype = {
    
    statusAlign: function Ext_StatusBarConfig$statusAlign(value) {
        /// <summary>
        /// The alignment of the status element within the overall StatusBar layout.  When the StatusBar is rendered, it creates an internal div containing the status text and icon.  Any additional Toolbar items added in the StatusBar's {@link #items} config, or added via {@link #add} or any of the supported add* methods, will be rendered, in added order, to the opposite side.  The status element is greedy, so it will automatically expand to take up all sapce left over by any other items.  Example usage: <pre><code> // Create a left-aligned status bar containing a button, // separator and text item that will be right-aligned (default): new Ext.Panel({ title: 'StatusBar', // etc. bbar: new Ext.StatusBar({ defaultText: 'Default status text', id: 'status-id', items: [{ text: 'A Button' }, '-', 'Plain Text'] }) }); // By adding the statusAlign config, this will create the // exact same toolbar, except the status and toolbar item // layout will be reversed from the previous example: new Ext.Panel({ title: 'StatusBar', // etc. bbar: new Ext.StatusBar({ defaultText: 'Default status text', id: 'status-id', statusAlign: 'right', items: [{ text: 'A Button' }, '-', 'Plain Text'] }) }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['statusAlign'] = value;
        return this;
    },
    
    defaultText: function Ext_StatusBarConfig$defaultText(value) {
        /// <summary>
        /// The default {@link #text} value.  This will be used anytime the status bar is cleared with the <tt>useDefaults:true</tt> option (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['defaultText'] = value;
        return this;
    },
    
    defaultIconCls: function Ext_StatusBarConfig$defaultIconCls(value) {
        /// <summary>
        /// The default {@link #iconCls} value (see the iconCls docs for additional details about customizing the icon). This will be used anytime the status bar is cleared with the <tt>useDefaults:true</tt> option (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['defaultIconCls'] = value;
        return this;
    },
    
    text: function Ext_StatusBarConfig$text(value) {
        /// <summary>
        /// A string that will be rendered into the status element as the status message (defaults to '');
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    iconCls: function Ext_StatusBarConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will be applied to the status element and is expected to provide a background image that will serve as the status bar icon (defaults to '').  The class is applied directly to the div that also contains the status text, so the rule should provide the appropriate padding on the div to make room for the image. Example usage:<pre><code> // Example CSS rule: .x-statusbar .x-status-custom { padding-left: 25px; background: transparent url(images/custom-icon.gif) no-repeat 3px 3px; } // Initializing the status bar: var sb = new Ext.StatusBar({ defaultIconCls: 'x-status-custom' }); // Setting it in code: sb.setStatus({ text: 'New status', iconCls: 'x-status-custom' }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    cls: function Ext_StatusBarConfig$cls(value) {
        /// <summary>
        /// The base class applied to the containing element for this component on render (defaults to 'x-statusbar')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    busyIconCls: function Ext_StatusBarConfig$busyIconCls(value) {
        /// <summary>
        /// The default {@link #iconCls} applied when calling {@link #showBusy} (defaults to 'x-status-busy'). It can be overridden at any time by passing the <tt>iconCls</tt> argument into <tt>showBusy</tt>. See the iconCls docs for additional details about customizing the icon.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['busyIconCls'] = value;
        return this;
    },
    
    busyText: function Ext_StatusBarConfig$busyText(value) {
        /// <summary>
        /// The default {@link #text} applied when calling {@link #showBusy} (defaults to 'Loading...'). It can be overridden at any time by passing the <tt>text</tt> argument into <tt>showBusy</tt>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['busyText'] = value;
        return this;
    },
    
    autoClear: function Ext_StatusBarConfig$autoClear(value) {
        /// <summary>
        /// The number of milliseconds to wait after setting the status via {@link #setStatus} before automatically clearing the status text and icon (defaults to 5000).  Note that this only applies when passing the <tt>clear</tt> argument to setStatus since that is the only way to defer clearing the status.  This can be overridden by specifying a different <tt>wait</tt> value in setStatus. Calls to {@link #clearStatus} always clear the status bar immediately and ignore this value.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['autoClear'] = value;
        return this;
    },
    
    x: function Ext_StatusBarConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_StatusBarConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_StatusBarConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_StatusBarConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_StatusBarConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_StatusBarConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_StatusBarConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_StatusBarConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_StatusBarConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_StatusBarConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_StatusBarConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_StatusBarConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_StatusBarConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_StatusBarConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_StatusBarConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_StatusBarConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_StatusBarConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_StatusBarConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_StatusBarConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_StatusBarConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_StatusBarConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_StatusBarConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_StatusBarConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_StatusBarConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_StatusBarConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_StatusBarConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StatusBarConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_StatusBarConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.StoreMgrConfig

Ext.StoreMgrConfig = function Ext_StoreMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.StoreMgrConfig.prototype = {
    
    listeners: function Ext_StoreMgrConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StoreMgrConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_StoreMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.StoreMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_StoreMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.TabPanelConfig

Ext.TabPanelConfig = function Ext_TabPanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.TabPanelConfig.prototype = {
    
    layoutOnTabChange: function Ext_TabPanelConfig$layoutOnTabChange(value) {
        /// <summary>
        /// Set to true to do a layout of tab items as tabs are changed.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['layoutOnTabChange'] = value;
        return this;
    },
    
    monitorResize: function Ext_TabPanelConfig$monitorResize(value) {
        /// <summary>
        /// True to automatically monitor window resize events and rerender the layout on browser resize (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['monitorResize'] = value;
        return this;
    },
    
    deferredRender: function Ext_TabPanelConfig$deferredRender(value) {
        /// <summary>
        /// Internally, the TabPanel uses a {@link Ext.layout.CardLayout} to manage its tabs. This property will be passed on to the layout as its {@link Ext.layout.CardLayout#deferredRender} config value, determining whether or not each tab is rendered only when first accessed (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['deferredRender'] = value;
        return this;
    },
    
    tabWidth: function Ext_TabPanelConfig$tabWidth(value) {
        /// <summary>
        /// The initial width in pixels of each new tab (defaults to 120).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tabWidth'] = value;
        return this;
    },
    
    minTabWidth: function Ext_TabPanelConfig$minTabWidth(value) {
        /// <summary>
        /// The minimum width in pixels for each tab when {@link #resizeTabs} = true (defaults to 30).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['minTabWidth'] = value;
        return this;
    },
    
    resizeTabs: function Ext_TabPanelConfig$resizeTabs(value) {
        /// <summary>
        /// True to automatically resize each tab so that the tabs will completely fill the tab strip (defaults to false).  Setting this to true may cause specific widths that might be set per tab to be overridden in order to fit them all into view (although {@link #minTabWidth} will always be honored).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['resizeTabs'] = value;
        return this;
    },
    
    enableTabScroll: function Ext_TabPanelConfig$enableTabScroll(value) {
        /// <summary>
        /// True to enable scrolling to tabs that may be invisible due to overflowing the overall TabPanel width. Only available with tabPosition:'top' (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['enableTabScroll'] = value;
        return this;
    },
    
    scrollIncrement: function Ext_TabPanelConfig$scrollIncrement(value) {
        /// <summary>
        /// The number of pixels to scroll each time a tab scroll button is pressed (defaults to 100, or if {@link #resizeTabs} = true, the calculated tab width).  Only applies when {@link #enableTabScroll} = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['scrollIncrement'] = value;
        return this;
    },
    
    scrollRepeatInterval: function Ext_TabPanelConfig$scrollRepeatInterval(value) {
        /// <summary>
        /// Number of milliseconds between each scroll while a tab scroll button is continuously pressed (defaults to 400).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['scrollRepeatInterval'] = value;
        return this;
    },
    
    scrollDuration: function Ext_TabPanelConfig$scrollDuration(value) {
        /// <summary>
        /// The number of milliseconds that each scroll animation should last (defaults to .35). Only applies when {@link #animScroll} = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['scrollDuration'] = value;
        return this;
    },
    
    animScroll: function Ext_TabPanelConfig$animScroll(value) {
        /// <summary>
        /// True to animate tab scrolling so that hidden tabs slide smoothly into view (defaults to true).  Only applies when {@link #enableTabScroll} = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['animScroll'] = value;
        return this;
    },
    
    tabPosition: function Ext_TabPanelConfig$tabPosition(value) {
        /// <summary>
        /// The position where the tab strip should be rendered (defaults to 'top').  The only other supported value is 'bottom'.  Note that tab scrolling is only supported for position 'top'.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tabPosition'] = value;
        return this;
    },
    
    baseCls: function Ext_TabPanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class applied to the panel (defaults to 'x-tab-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    autoTabs: function Ext_TabPanelConfig$autoTabs(value) {
        /// <summary>
        /// <p>True to query the DOM for any divs with a class of 'x-tab' to be automatically converted to tabs and added to this panel (defaults to false).  Note that the query will be executed within the scope of the container element only (so that multiple tab panels from markup can be supported via this method).</p><p>This method is only possible when the markup is structured correctly as a container with nested divs containing the class 'x-tab'. To create TabPanels without these limitations, or to pull tab content from other elements on the page, see the example at the top of the class for generating tabs from markup.</p><p>There are a couple of things to note when using this method:<ul><li>When using the autoTabs config (as opposed to passing individual tab configs in the TabPanel's {@link #items} collection), you must use {@link #applyTo} to correctly use the specified id as the tab container. The autoTabs method <em>replaces</em> existing content with the TabPanel components.</li><li>Make sure that you set {@link #deferredRender} to false so that the content elements for each tab will be rendered into the TabPanel immediately upon page load, otherwise they will not be transformed until each tab is activated and will be visible outside the TabPanel.</li></ul>Example usage:</p><pre><code> var tabs = new Ext.TabPanel({ applyTo: 'my-tabs', activeTab: 0, deferredRender: false, autoTabs: true }); // This markup will be converted to a TabPanel from the code above &lt;div id="my-tabs"&gt; &lt;div class="x-tab" title="Tab 1"&gt;A simple tab&lt;/div&gt; &lt;div class="x-tab" title="Tab 2"&gt;Another one&lt;/div&gt; &lt;/div&gt; </code></pre>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoTabs'] = value;
        return this;
    },
    
    autoTabSelector: function Ext_TabPanelConfig$autoTabSelector(value) {
        /// <summary>
        /// The CSS selector used to search for tabs in existing markup when {@link #autoTabs} = true (defaults to 'div.x-tab').  This can be any valid selector supported by {@link Ext.DomQuery#select}. Note that the query will be executed within the scope of this tab panel only (so that multiple tab panels from markup can be supported on a page).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoTabSelector'] = value;
        return this;
    },
    
    activeTab: function Ext_TabPanelConfig$activeTab(value) {
        /// <summary>
        /// {String/Number} A string id or the numeric index of the tab that should be initially activated on render (defaults to none).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['activeTab'] = value;
        return this;
    },
    
    tabMargin: function Ext_TabPanelConfig$tabMargin(value) {
        /// <summary>
        /// The number of pixels of space to calculate into the sizing and scrolling of tabs. If you change the margin in CSS, you will need to update this value so calculations are correct with either resizeTabs or scrolling tabs. (defaults to 2)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tabMargin'] = value;
        return this;
    },
    
    plain: function Ext_TabPanelConfig$plain(value) {
        /// <summary>
        /// True to render the tab strip without a background container image (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['plain'] = value;
        return this;
    },
    
    wheelIncrement: function Ext_TabPanelConfig$wheelIncrement(value) {
        /// <summary>
        /// For scrolling tabs, the number of pixels to increment on mouse wheel scrolling (defaults to 20).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['wheelIncrement'] = value;
        return this;
    },
    
    applyTo: function Ext_TabPanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_TabPanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_TabPanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_TabPanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_TabPanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_TabPanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_TabPanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_TabPanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_TabPanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_TabPanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_TabPanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_TabPanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_TabPanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_TabPanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_TabPanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_TabPanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_TabPanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_TabPanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_TabPanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_TabPanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_TabPanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_TabPanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_TabPanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_TabPanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_TabPanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_TabPanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_TabPanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    collapsedCls: function Ext_TabPanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_TabPanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_TabPanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_TabPanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_TabPanelConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_TabPanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_TabPanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_TabPanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_TabPanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_TabPanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_TabPanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_TabPanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_TabPanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_TabPanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_TabPanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_TabPanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_TabPanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_TabPanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_TabPanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_TabPanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_TabPanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_TabPanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_TabPanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_TabPanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_TabPanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_TabPanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_TabPanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_TabPanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_TabPanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_TabPanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_TabPanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_TabPanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_TabPanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_TabPanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_TabPanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_TabPanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_TabPanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_TabPanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_TabPanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_TabPanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_TabPanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_TabPanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TabPanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_TabPanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.TabPanelEvents

Ext.TabPanelEvents = function Ext_TabPanelEvents() {
}
Ext.TabPanelEvents.get_beforetabchange = function Ext_TabPanelEvents$get_beforetabchange() {
    /// <summary>
    /// Fires before the active tab changes. Handlers can return false to cancel the tab change.
    /// <pre><code>
    /// USAGE: ({TabPanel} objthis, {Panel} newTab, {Panel} currentTab)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>newTab</b></term><description>The tab being activated</description></item><item><term><b>currentTab</b></term><description>The current active tab</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforetabchange';
}
Ext.TabPanelEvents.get_tabchange = function Ext_TabPanelEvents$get_tabchange() {
    /// <summary>
    /// Fires after the active tab has changed.
    /// <pre><code>
    /// USAGE: ({TabPanel} objthis, {Panel} tab)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>tab</b></term><description>The new active tab</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'tabchange';
}
Ext.TabPanelEvents.get_contextmenu = function Ext_TabPanelEvents$get_contextmenu() {
    /// <summary>
    /// Fires when the original browser contextmenu event originated from a tab element.
    /// <pre><code>
    /// USAGE: ({TabPanel} objthis, {Panel} tab, {EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>tab</b></term><description>The target tab</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'contextmenu';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.TaskMgrConfig

Ext.TaskMgrConfig = function Ext_TaskMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.TaskMgrConfig.prototype = {
    
    custom: function Ext_TaskMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TaskMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_TaskMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.TemplateConfig

Ext.TemplateConfig = function Ext_TemplateConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.TemplateConfig.prototype = {
    
    custom: function Ext_TemplateConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TemplateConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_TemplateConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.TipConfig

Ext.TipConfig = function Ext_TipConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.TipConfig.prototype = {
    
    closable: function Ext_TipConfig$closable(value) {
        /// <summary>
        /// True to render a close tool button into the tooltip header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['closable'] = value;
        return this;
    },
    
    width: function Ext_TipConfig$width(value) {
        /// <summary>
        /// Width in pixels of the tip (defaults to auto).  Width will be ignored if it exceeds the bounds of {@link #minWidth} or {@link #maxWidth}.  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    minWidth: function Ext_TipConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the tip in pixels (defaults to 40).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    maxWidth: function Ext_TipConfig$maxWidth(value) {
        /// <summary>
        /// The maximum width of the tip in pixels (defaults to 300).  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['maxWidth'] = value;
        return this;
    },
    
    shadow: function Ext_TipConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    defaultAlign: function Ext_TipConfig$defaultAlign(value) {
        /// <summary>
        /// <b>Experimental</b>. The default {@link Ext.Element#alignTo} anchor position value for this tip relative to its element of origin (defaults to "tl-bl?").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    applyTo: function Ext_TipConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_TipConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_TipConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_TipConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_TipConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_TipConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_TipConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_TipConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_TipConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_TipConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_TipConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_TipConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_TipConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_TipConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_TipConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_TipConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_TipConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_TipConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_TipConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadowOffset: function Ext_TipConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_TipConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_TipConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_TipConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_TipConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_TipConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_TipConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_TipConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_TipConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_TipConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_TipConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_TipConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_TipConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_TipConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_TipConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_TipConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_TipConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_TipConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_TipConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_TipConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_TipConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_TipConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_TipConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_TipConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_TipConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_TipConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_TipConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_TipConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_TipConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    autoHeight: function Ext_TipConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_TipConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_TipConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_TipConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_TipConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_TipConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_TipConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_TipConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_TipConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_TipConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_TipConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_TipConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_TipConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_TipConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_TipConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_TipConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_TipConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_TipConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_TipConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_TipConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.TipConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_TipConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ToolbarConfig

Ext.ToolbarConfig = function Ext_ToolbarConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ToolbarConfig.prototype = {
    
    x: function Ext_ToolbarConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ToolbarConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ToolbarConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ToolbarConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ToolbarConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_ToolbarConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_ToolbarConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ToolbarConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ToolbarConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ToolbarConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ToolbarConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ToolbarConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ToolbarConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ToolbarConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ToolbarConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ToolbarConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ToolbarConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ToolbarConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ToolbarConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ToolbarConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ToolbarConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ToolbarConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ToolbarConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ToolbarConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ToolbarConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ToolbarConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ToolbarConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolbarConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ToolbarConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ToolTipConfig

Ext.ToolTipConfig = function Ext_ToolTipConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ToolTipConfig.prototype = {
    
    target: function Ext_ToolTipConfig$target(value) {
        /// <summary>
        /// The target HTMLElement, Ext.Element or id to associate with this tooltip.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['target'] = value;
        return this;
    },
    
    autoHide: function Ext_ToolTipConfig$autoHide(value) {
        /// <summary>
        /// True to automatically hide the tooltip after the mouse exits the target element or after the {@link #dismissDelay} has expired if set (defaults to true).  If {@link closable} = true a close tool button will be rendered into the tooltip header.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoHide'] = value;
        return this;
    },
    
    showDelay: function Ext_ToolTipConfig$showDelay(value) {
        /// <summary>
        /// Delay in milliseconds before the tooltip displays after the mouse enters the target element (defaults to 500)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['showDelay'] = value;
        return this;
    },
    
    hideDelay: function Ext_ToolTipConfig$hideDelay(value) {
        /// <summary>
        /// Delay in milliseconds after the mouse exits the target element but before the tooltip actually hides (defaults to 200).  Set to 0 for the tooltip to hide immediately.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    dismissDelay: function Ext_ToolTipConfig$dismissDelay(value) {
        /// <summary>
        /// Delay in milliseconds before the tooltip automatically hides (defaults to 5000). To disable automatic hiding, set dismissDelay = 0.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['dismissDelay'] = value;
        return this;
    },
    
    mouseOffset: function Ext_ToolTipConfig$mouseOffset(value) {
        /// <summary>
        /// An XY offset from the mouse position where the tooltip should be shown (defaults to [15,18]).
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['mouseOffset'] = value;
        return this;
    },
    
    trackMouse: function Ext_ToolTipConfig$trackMouse(value) {
        /// <summary>
        /// True to have the tooltip follow the mouse as it moves over the target element (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['trackMouse'] = value;
        return this;
    },
    
    closable: function Ext_ToolTipConfig$closable(value) {
        /// <summary>
        /// True to render a close tool button into the tooltip header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['closable'] = value;
        return this;
    },
    
    width: function Ext_ToolTipConfig$width(value) {
        /// <summary>
        /// Width in pixels of the tip (defaults to auto).  Width will be ignored if it exceeds the bounds of {@link #minWidth} or {@link #maxWidth}.  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    minWidth: function Ext_ToolTipConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the tip in pixels (defaults to 40).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    maxWidth: function Ext_ToolTipConfig$maxWidth(value) {
        /// <summary>
        /// The maximum width of the tip in pixels (defaults to 300).  The maximum supported value is 500.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['maxWidth'] = value;
        return this;
    },
    
    shadow: function Ext_ToolTipConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    defaultAlign: function Ext_ToolTipConfig$defaultAlign(value) {
        /// <summary>
        /// <b>Experimental</b>. The default {@link Ext.Element#alignTo} anchor position value for this tip relative to its element of origin (defaults to "tl-bl?").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    applyTo: function Ext_ToolTipConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_ToolTipConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_ToolTipConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_ToolTipConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_ToolTipConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_ToolTipConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_ToolTipConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_ToolTipConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_ToolTipConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_ToolTipConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_ToolTipConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_ToolTipConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_ToolTipConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_ToolTipConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_ToolTipConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_ToolTipConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_ToolTipConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_ToolTipConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_ToolTipConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadowOffset: function Ext_ToolTipConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_ToolTipConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_ToolTipConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_ToolTipConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_ToolTipConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_ToolTipConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_ToolTipConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_ToolTipConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_ToolTipConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_ToolTipConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_ToolTipConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_ToolTipConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_ToolTipConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_ToolTipConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_ToolTipConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_ToolTipConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_ToolTipConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_ToolTipConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_ToolTipConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_ToolTipConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_ToolTipConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_ToolTipConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_ToolTipConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_ToolTipConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_ToolTipConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ToolTipConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ToolTipConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ToolTipConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ToolTipConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    autoHeight: function Ext_ToolTipConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ToolTipConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ToolTipConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ToolTipConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ToolTipConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ToolTipConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ToolTipConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ToolTipConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ToolTipConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ToolTipConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_ToolTipConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ToolTipConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ToolTipConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ToolTipConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ToolTipConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ToolTipConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ToolTipConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ToolTipConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ToolTipConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ToolTipConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ToolTipConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ToolTipConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.UpdaterConfig

Ext.UpdaterConfig = function Ext_UpdaterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.UpdaterConfig.prototype = {
    
    listeners: function Ext_UpdaterConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.UpdaterConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_UpdaterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.UpdaterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_UpdaterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.UpdaterEvents

Ext.UpdaterEvents = function Ext_UpdaterEvents() {
}
Ext.UpdaterEvents.get_beforeupdate = function Ext_UpdaterEvents$get_beforeupdate() {
    /// <summary>
    /// Fired before an update is made, return false from your handler and the update is cancelled.
    /// <pre><code>
    /// USAGE: ({Ext.Element} el, {String/Object/Function} url, {String/Object} prms)
    /// </code></pre><list type="bullet"><item><term><b>el</b></term><description></description></item><item><term><b>url</b></term><description></description></item><item><term><b>prms</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeupdate';
}
Ext.UpdaterEvents.get_update = function Ext_UpdaterEvents$get_update() {
    /// <summary>
    /// Fired after successful update is made.
    /// <pre><code>
    /// USAGE: ({Ext.Element} el, {Object} oResponseObject)
    /// </code></pre><list type="bullet"><item><term><b>el</b></term><description></description></item><item><term><b>oResponseObject</b></term><description>The response Object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'update';
}
Ext.UpdaterEvents.get_failure = function Ext_UpdaterEvents$get_failure() {
    /// <summary>
    /// Fired on update failure.
    /// <pre><code>
    /// USAGE: ({Ext.Element} el, {Object} oResponseObject)
    /// </code></pre><list type="bullet"><item><term><b>el</b></term><description></description></item><item><term><b>oResponseObject</b></term><description>The response Object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'failure';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.ViewportConfig

Ext.ViewportConfig = function Ext_ViewportConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ViewportConfig.prototype = {
    
    defaultType: function Ext_ViewportConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_ViewportConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_ViewportConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_ViewportConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_ViewportConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_ViewportConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_ViewportConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_ViewportConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ViewportConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ViewportConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ViewportConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ViewportConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_ViewportConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_ViewportConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ViewportConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ViewportConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ViewportConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ViewportConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_ViewportConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_ViewportConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ViewportConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ViewportConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ViewportConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ViewportConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ViewportConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ViewportConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ViewportConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ViewportConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ViewportConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ViewportConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ViewportConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ViewportConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ViewportConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ViewportConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ViewportConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ViewportConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.WindowConfig

Ext.WindowConfig = function Ext_WindowConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.WindowConfig.prototype = {
    
    x: function Ext_WindowConfig$x(value) {
        /// <summary>
        /// The X position of the left edge of the Window on initial showing. Defaults to centering the Window within the width of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_WindowConfig$y(value) {
        /// <summary>
        /// The Y position of the top edge of the Window on initial showing. Defaults to centering the Window within the height of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    modal: function Ext_WindowConfig$modal(value) {
        /// <summary>
        /// True to make the window modal and mask everything behind it when displayed, false to display it without restricting access to other UI elements (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['modal'] = value;
        return this;
    },
    
    animateTarget: function Ext_WindowConfig$animateTarget(value) {
        /// <summary>
        /// {String/Element}  Id or element from which the window should animate while opening (defaults to null with no animation).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['animateTarget'] = value;
        return this;
    },
    
    resizeHandles: function Ext_WindowConfig$resizeHandles(value) {
        /// <summary>
        /// A valid {@link Ext.Resizable} handles config string (defaults to 'all').  Only applies when resizable = true.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['resizeHandles'] = value;
        return this;
    },
    
    manager: function Ext_WindowConfig$manager(value) {
        /// <summary>
        /// A reference to the WindowGroup that should manage this window (defaults to {@link Ext.WindowMgr}).
        /// </summary>
        /// <param name="value" type="Ext.WindowGroup">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['manager'] = value;
        return this;
    },
    
    defaultButton: function Ext_WindowConfig$defaultButton(value) {
        /// <summary>
        /// {String/Number/Button}  The id / index of a button or a button instance to focus when this window received the focus.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['defaultButton'] = value;
        return this;
    },
    
    onEsc: function Ext_WindowConfig$onEsc(value) {
        /// <summary>
        /// Allows override of the built-in processing for the escape key. Default action is to close the Window (performing whatever action is specified in {@link #closeAction}. To prevent the Window closing when the escape key is pressed, specify this as Ext.emptyFn (See {@link Ext#emptyFn}).
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['onEsc'] = value;
        return this;
    },
    
    baseCls: function Ext_WindowConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-window').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    resizable: function Ext_WindowConfig$resizable(value) {
        /// <summary>
        /// True to allow user resizing at each edge and corner of the window, false to disable resizing (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    draggable: function Ext_WindowConfig$draggable(value) {
        /// <summary>
        /// True to allow the window to be dragged by the header bar, false to disable dragging (defaults to true).  Note that by default the window will be centered in the viewport, so if dragging is disabled the window may need to be positioned programmatically after render (e.g., myWindow.setPosition(100, 100);).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    closable: function Ext_WindowConfig$closable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['closable'] = value;
        return this;
    },
    
    constrain: function Ext_WindowConfig$constrain(value) {
        /// <summary>
        /// True to constrain the window to the viewport, false to allow it to fall outside of the viewport (defaults to false).  Optionally the header only can be constrained using {@link #constrainHeader}.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['constrain'] = value;
        return this;
    },
    
    constrainHeader: function Ext_WindowConfig$constrainHeader(value) {
        /// <summary>
        /// True to constrain the window header to the viewport, allowing the window body to fall outside of the viewport, false to allow the header to fall outside the viewport (defaults to false).  Optionally the entire window can be constrained using {@link #constrain}.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['constrainHeader'] = value;
        return this;
    },
    
    plain: function Ext_WindowConfig$plain(value) {
        /// <summary>
        /// True to render the window body with a transparent background so that it will blend into the framing elements, false to add a lighter background color to visually highlight the body element and separate it more distinctly from the surrounding frame (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['plain'] = value;
        return this;
    },
    
    minimizable: function Ext_WindowConfig$minimizable(value) {
        /// <summary>
        /// True to display the 'minimize' tool button and allow the user to minimize the window, false to hide the button and disallow minimizing the window (defaults to false).  Note that this button provides no implementation -- the behavior of minimizing a window is implementation-specific, so the minimize event must be handled and a custom minimize behavior implemented for this option to be useful.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['minimizable'] = value;
        return this;
    },
    
    maximizable: function Ext_WindowConfig$maximizable(value) {
        /// <summary>
        /// True to display the 'maximize' tool button and allow the user to maximize the window, false to hide the button and disallow maximizing the window (defaults to false).  Note that when a window is maximized, the tool button will automatically change to a 'restore' button with the appropriate behavior already built-in that will restore the window to its previous size.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['maximizable'] = value;
        return this;
    },
    
    minHeight: function Ext_WindowConfig$minHeight(value) {
        /// <summary>
        /// The minimum height in pixels allowed for this window (defaults to 100).  Only applies when resizable = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    minWidth: function Ext_WindowConfig$minWidth(value) {
        /// <summary>
        /// The minimum width in pixels allowed for this window (defaults to 200).  Only applies when resizable = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    expandOnShow: function Ext_WindowConfig$expandOnShow(value) {
        /// <summary>
        /// True to always expand the window when it is displayed, false to keep it in its current state (which may be collapsed) when displayed (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['expandOnShow'] = value;
        return this;
    },
    
    closeAction: function Ext_WindowConfig$closeAction(value) {
        /// <summary>
        /// The action to take when the close button is clicked.  The default action is 'close' which will actually remove the window from the DOM and destroy it.  The other valid option is 'hide' which will simply hide the window by setting visibility to hidden and applying negative offsets, keeping the window available to be redisplayed via the {@link #show} method.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['closeAction'] = value;
        return this;
    },
    
    elements: function Ext_WindowConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    applyTo: function Ext_WindowConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_WindowConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_WindowConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_WindowConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_WindowConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_WindowConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_WindowConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_WindowConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_WindowConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_WindowConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_WindowConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_WindowConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_WindowConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_WindowConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_WindowConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_WindowConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_WindowConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_WindowConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_WindowConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_WindowConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_WindowConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_WindowConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_WindowConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_WindowConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_WindowConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    tabTip: function Ext_WindowConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    collapsedCls: function Ext_WindowConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_WindowConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_WindowConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_WindowConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_WindowConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_WindowConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_WindowConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_WindowConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    defaultType: function Ext_WindowConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_WindowConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_WindowConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_WindowConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_WindowConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_WindowConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_WindowConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    pageX: function Ext_WindowConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_WindowConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_WindowConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_WindowConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_WindowConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_WindowConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_WindowConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_WindowConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_WindowConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_WindowConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_WindowConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_WindowConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_WindowConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_WindowConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_WindowConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_WindowConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_WindowConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_WindowConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_WindowConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_WindowConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_WindowConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_WindowConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_WindowConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_WindowConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_WindowConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.WindowEvents

Ext.WindowEvents = function Ext_WindowEvents() {
}
Ext.WindowEvents.get_activate = function Ext_WindowEvents$get_activate() {
    /// <summary>
    /// Fires after the window has been visually activated via {@link setActive}.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'activate';
}
Ext.WindowEvents.get_deactivate = function Ext_WindowEvents$get_deactivate() {
    /// <summary>
    /// Fires after the window has been visually deactivated via {@link setActive}.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'deactivate';
}
Ext.WindowEvents.get_resize = function Ext_WindowEvents$get_resize() {
    /// <summary>
    /// Fires after the window has been resized.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis, {Number} width, {Number} height)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>width</b></term><description>The window's new width</description></item><item><term><b>height</b></term><description>The window's new height</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'resize';
}
Ext.WindowEvents.get_maximize = function Ext_WindowEvents$get_maximize() {
    /// <summary>
    /// Fires after the window has been maximized.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'maximize';
}
Ext.WindowEvents.get_minimize = function Ext_WindowEvents$get_minimize() {
    /// <summary>
    /// Fires after the window has been minimized.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'minimize';
}
Ext.WindowEvents.get_restore = function Ext_WindowEvents$get_restore() {
    /// <summary>
    /// Fires after the window has been restored to its original size after being maximized.
    /// <pre><code>
    /// USAGE: ({Ext.Window} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'restore';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.WindowGroupConfig

Ext.WindowGroupConfig = function Ext_WindowGroupConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.WindowGroupConfig.prototype = {
    
    custom: function Ext_WindowGroupConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowGroupConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_WindowGroupConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.WindowMgrConfig

Ext.WindowMgrConfig = function Ext_WindowMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.WindowMgrConfig.prototype = {
    
    custom: function Ext_WindowMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.WindowMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_WindowMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.XTemplateConfig

Ext.XTemplateConfig = function Ext_XTemplateConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.XTemplateConfig.prototype = {
    
    custom: function Ext_XTemplateConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.XTemplateConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_XTemplateConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.data');

////////////////////////////////////////////////////////////////////////////////
// Ext.data.ArrayReaderConfig

Ext.data.ArrayReaderConfig = function Ext_data_ArrayReaderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.ArrayReaderConfig.prototype = {
    
    id: function Ext_data_ArrayReaderConfig$id(value) {
        /// <summary>
        /// (optional) The subscript within row Array that provides an ID for the Record
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ArrayReaderConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    totalProperty: function Ext_data_ArrayReaderConfig$totalProperty(value) {
        /// <summary>
        /// Name of the property from which to retrieve the total number of records
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ArrayReaderConfig"></returns>
        this.o['totalProperty'] = value;
        return this;
    },
    
    successProperty: function Ext_data_ArrayReaderConfig$successProperty(value) {
        /// <summary>
        /// Name of the property from which to retrieve the success attribute used by forms.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ArrayReaderConfig"></returns>
        this.o['successProperty'] = value;
        return this;
    },
    
    root: function Ext_data_ArrayReaderConfig$root(value) {
        /// <summary>
        /// name of the property which contains the Array of row objects.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ArrayReaderConfig"></returns>
        this.o['root'] = value;
        return this;
    },
    
    custom: function Ext_data_ArrayReaderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ArrayReaderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_ArrayReaderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.ConnectionConfig

Ext.data.ConnectionConfig = function Ext_data_ConnectionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.ConnectionConfig.prototype = {
    
    url: function Ext_data_ConnectionConfig$url(value) {
        /// <summary>
        /// (Optional) The default URL to be used for requests to the server. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    extraParams: function Ext_data_ConnectionConfig$extraParams(value) {
        /// <summary>
        /// (Optional) An object containing properties which are used as extra parameters to each request made by this object. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['extraParams'] = value;
        return this;
    },
    
    defaultHeaders: function Ext_data_ConnectionConfig$defaultHeaders(value) {
        /// <summary>
        /// (Optional) An object containing request headers which are added to each request made by this object. (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['defaultHeaders'] = value;
        return this;
    },
    
    method: function Ext_data_ConnectionConfig$method(value) {
        /// <summary>
        /// (Optional) The default HTTP method to be used for requests. (defaults to undefined; if not set, but {@link #request} params are present, POST will be used; otherwise, GET will be used.)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    timeout: function Ext_data_ConnectionConfig$timeout(value) {
        /// <summary>
        /// (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    autoAbort: function Ext_data_ConnectionConfig$autoAbort(value) {
        /// <summary>
        /// (Optional) Whether this request should abort any pending requests. (defaults to false) @type Boolean
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['autoAbort'] = value;
        return this;
    },
    
    disableCaching: function Ext_data_ConnectionConfig$disableCaching(value) {
        /// <summary>
        /// (Optional) True to add a unique cache-buster param to GET requests. (defaults to true) @type Boolean
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['disableCaching'] = value;
        return this;
    },
    
    listeners: function Ext_data_ConnectionConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_ConnectionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ConnectionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_ConnectionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.ConnectionEvents

Ext.data.ConnectionEvents = function Ext_data_ConnectionEvents() {
}
Ext.data.ConnectionEvents.get_beforerequest = function Ext_data_ConnectionEvents$get_beforerequest() {
    /// <summary>
    /// Fires before a network request is made to retrieve a data object.
    /// <pre><code>
    /// USAGE: ({Connection} conn, {Object} options)
    /// </code></pre><list type="bullet"><item><term><b>conn</b></term><description>This Connection object.</description></item><item><term><b>options</b></term><description>The options config object passed to the {@link #request} method.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerequest';
}
Ext.data.ConnectionEvents.get_requestcomplete = function Ext_data_ConnectionEvents$get_requestcomplete() {
    /// <summary>
    /// Fires if the request was successfully completed.
    /// See <a href="http://www.w3.org/TR/XMLHttpRequest/">The XMLHttpRequest Object</a>
    /// for details.
    /// <pre><code>
    /// USAGE: ({Connection} conn, {Object} response, {Object} options)
    /// </code></pre><list type="bullet"><item><term><b>conn</b></term><description>This Connection object.</description></item><item><term><b>response</b></term><description>The XHR object containing the response data.</description></item><item><term><b>options</b></term><description>The options config object passed to the {@link #request} method.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'requestcomplete';
}
Ext.data.ConnectionEvents.get_requestexception = function Ext_data_ConnectionEvents$get_requestexception() {
    /// <summary>
    /// Fires if an error HTTP status was returned from the server.
    /// See <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html">HTTP Status Code Definitions</a>
    /// for details of HTTP status codes.
    /// See <a href="http://www.w3.org/TR/XMLHttpRequest/">The XMLHttpRequest Object</a>
    /// for details.
    /// <pre><code>
    /// USAGE: ({Connection} conn, {Object} response, {Object} options)
    /// </code></pre><list type="bullet"><item><term><b>conn</b></term><description>This Connection object.</description></item><item><term><b>response</b></term><description>The XHR object containing the response data.</description></item><item><term><b>options</b></term><description>The options config object passed to the {@link #request} method.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'requestexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.DataProxyConfig

Ext.data.DataProxyConfig = function Ext_data_DataProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.DataProxyConfig.prototype = {
    
    listeners: function Ext_data_DataProxyConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.DataProxyConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_DataProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.DataProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_DataProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.DataProxyEvents

Ext.data.DataProxyEvents = function Ext_data_DataProxyEvents() {
}
Ext.data.DataProxyEvents.get_beforeload = function Ext_data_DataProxyEvents$get_beforeload() {
    /// <summary>
    /// Fires before a network request is made to retrieve a data object.
    /// <pre><code>
    /// USAGE: ({Object} objthis, {Object} prms)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>prms</b></term><description>The params object passed to the {@link #load} function</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeload';
}
Ext.data.DataProxyEvents.get_load = function Ext_data_DataProxyEvents$get_load() {
    /// <summary>
    /// Fires before the load method's callback is called.
    /// <pre><code>
    /// USAGE: ({Object} objthis, {Object} o, {Object} arg)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>o</b></term><description>The data object</description></item><item><term><b>arg</b></term><description>The callback's arg object passed to the {@link #load} function</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'load';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.DataReaderConfig

Ext.data.DataReaderConfig = function Ext_data_DataReaderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.DataReaderConfig.prototype = {
    
    custom: function Ext_data_DataReaderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.DataReaderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_DataReaderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.GroupingStoreConfig

Ext.data.GroupingStoreConfig = function Ext_data_GroupingStoreConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.GroupingStoreConfig.prototype = {
    
    groupField: function Ext_data_GroupingStoreConfig$groupField(value) {
        /// <summary>
        /// The field name by which to sort the store's data (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['groupField'] = value;
        return this;
    },
    
    remoteGroup: function Ext_data_GroupingStoreConfig$remoteGroup(value) {
        /// <summary>
        /// True if the grouping should apply on the server side, false if it is local only (defaults to false).  If the grouping is local, it can be applied immediately to the data.  If it is remote, then it will simply act as a helper, automatically sending the grouping field name as the 'groupBy' param with each XHR call.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['remoteGroup'] = value;
        return this;
    },
    
    groupOnSort: function Ext_data_GroupingStoreConfig$groupOnSort(value) {
        /// <summary>
        /// True to sort the data on the grouping field when a grouping operation occurs, false to sort based on the existing sort info (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['groupOnSort'] = value;
        return this;
    },
    
    storeId: function Ext_data_GroupingStoreConfig$storeId(value) {
        /// <summary>
        /// If passed, the id to use to register with the StoreMgr
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['storeId'] = value;
        return this;
    },
    
    url: function Ext_data_GroupingStoreConfig$url(value) {
        /// <summary>
        /// If passed, an HttpProxy is created for the passed URL
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    autoLoad: function Ext_data_GroupingStoreConfig$autoLoad(value) {
        /// <summary>
        /// {Boolean/Object} If passed, this store's load method is automatically called after creation with the autoLoad object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    proxy: function Ext_data_GroupingStoreConfig$proxy(value) {
        /// <summary>
        /// The Proxy object which provides access to a data object.
        /// </summary>
        /// <param name="value" type="Ext.data.DataProxy">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['proxy'] = value;
        return this;
    },
    
    data: function Ext_data_GroupingStoreConfig$data(value) {
        /// <summary>
        /// Inline data to be loaded when the store is initialized.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['data'] = value;
        return this;
    },
    
    reader: function Ext_data_GroupingStoreConfig$reader(value) {
        /// <summary>
        /// The DataReader object which processes the data object and returns an Array of Ext.data.Record objects which are cached keyed by their <em>id</em> property.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    baseParams: function Ext_data_GroupingStoreConfig$baseParams(value) {
        /// <summary>
        /// An object containing properties which are to be sent as parameters on any HTTP request
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    sortInfo: function Ext_data_GroupingStoreConfig$sortInfo(value) {
        /// <summary>
        /// A config object in the format: {field: "fieldName", direction: "ASC|DESC"}.  The direction property is case-sensitive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['sortInfo'] = value;
        return this;
    },
    
    remoteSort: function Ext_data_GroupingStoreConfig$remoteSort(value) {
        /// <summary>
        /// True if sorting is to be handled by requesting the Proxy to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to false). <p>If remote sorting is specified, then clicking on a column header causes the current page to be requested from the server with the addition of the following two parameters: <div class="mdetail-params"><ul><li><b>sort</b> : String<p class="sub-desc">The name (as specified in the Record's Field definition) of the field to sort on.</p></li><li><b>dir</b> : String<p class="sub-desc">The direction of the sort, "ASC" or "DESC" (case-sensitive).</p></li></ul></div></p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['remoteSort'] = value;
        return this;
    },
    
    pruneModifiedRecords: function Ext_data_GroupingStoreConfig$pruneModifiedRecords(value) {
        /// <summary>
        /// True to clear all modified record information each time the store is loaded or when a record is removed. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['pruneModifiedRecords'] = value;
        return this;
    },
    
    listeners: function Ext_data_GroupingStoreConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_GroupingStoreConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.GroupingStoreConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_GroupingStoreConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.HttpProxyConfig

Ext.data.HttpProxyConfig = function Ext_data_HttpProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.HttpProxyConfig.prototype = {
    
    listeners: function Ext_data_HttpProxyConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.HttpProxyConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    url: function Ext_data_HttpProxyConfig$url(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.HttpProxyConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    custom: function Ext_data_HttpProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.HttpProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_HttpProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.HttpProxyEvents

Ext.data.HttpProxyEvents = function Ext_data_HttpProxyEvents() {
}
Ext.data.HttpProxyEvents.get_loadexception = function Ext_data_HttpProxyEvents$get_loadexception() {
    /// <summary>
    /// Fires if an exception occurs in the Proxy during data loading.  This event can be fired for one of two reasons:
    /// <ul><li><b>The load call returned success: false.</b>  This means the server logic returned a failure
    /// status and there is no data to read.  In this case, this event will be raised and the
    /// fourth parameter (read error) will be null.</li><li><b>The load succeeded but the reader could not read the response.</b>  This means the server returned
    /// data, but the configured Reader threw an error while reading the data.  In this case, this event will be
    /// raised and the caught error will be passed along as the fourth parameter of this event.</li></ul>
    /// Note that this event is also relayed through {@link Ext.data.Store}, so you can listen for it directly
    /// on any Store instance.
    /// If the load call returned success: false, this parameter will be null.
    /// <pre><code>
    /// USAGE: ({Object} objthis, {Object} options, {Object} response, {Error} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>options</b></term><description>The loading options that were specified (see {@link #load} for details)</description></item><item><term><b>response</b></term><description>The XMLHttpRequest object containing the response data</description></item><item><term><b>e</b></term><description>The JavaScript Error object caught if the configured Reader could not read the data.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'loadexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.JsonReaderConfig

Ext.data.JsonReaderConfig = function Ext_data_JsonReaderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.JsonReaderConfig.prototype = {
    
    totalProperty: function Ext_data_JsonReaderConfig$totalProperty(value) {
        /// <summary>
        /// Name of the property from which to retrieve the total number of records
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonReaderConfig"></returns>
        this.o['totalProperty'] = value;
        return this;
    },
    
    successProperty: function Ext_data_JsonReaderConfig$successProperty(value) {
        /// <summary>
        /// Name of the property from which to retrieve the success attribute used by forms.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonReaderConfig"></returns>
        this.o['successProperty'] = value;
        return this;
    },
    
    root: function Ext_data_JsonReaderConfig$root(value) {
        /// <summary>
        /// name of the property which contains the Array of row objects.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonReaderConfig"></returns>
        this.o['root'] = value;
        return this;
    },
    
    id: function Ext_data_JsonReaderConfig$id(value) {
        /// <summary>
        /// Name of the property within a row object that contains a record identifier value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonReaderConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    custom: function Ext_data_JsonReaderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonReaderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_JsonReaderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.JsonStoreConfig

Ext.data.JsonStoreConfig = function Ext_data_JsonStoreConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.JsonStoreConfig.prototype = {
    
    url: function Ext_data_JsonStoreConfig$url(value) {
        /// <summary>
        /// The URL from which to load data through an HttpProxy. Either this
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    data: function Ext_data_JsonStoreConfig$data(value) {
        /// <summary>
        /// A data object readable by this object's JsonReader. Either this
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['data'] = value;
        return this;
    },
    
    fields: function Ext_data_JsonStoreConfig$fields(value) {
        /// <summary>
        /// Either an Array of field definition objects as passed to
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['fields'] = value;
        return this;
    },
    
    storeId: function Ext_data_JsonStoreConfig$storeId(value) {
        /// <summary>
        /// If passed, the id to use to register with the StoreMgr
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['storeId'] = value;
        return this;
    },
    
    autoLoad: function Ext_data_JsonStoreConfig$autoLoad(value) {
        /// <summary>
        /// {Boolean/Object} If passed, this store's load method is automatically called after creation with the autoLoad object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    proxy: function Ext_data_JsonStoreConfig$proxy(value) {
        /// <summary>
        /// The Proxy object which provides access to a data object.
        /// </summary>
        /// <param name="value" type="Ext.data.DataProxy">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['proxy'] = value;
        return this;
    },
    
    reader: function Ext_data_JsonStoreConfig$reader(value) {
        /// <summary>
        /// The DataReader object which processes the data object and returns an Array of Ext.data.Record objects which are cached keyed by their <em>id</em> property.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    baseParams: function Ext_data_JsonStoreConfig$baseParams(value) {
        /// <summary>
        /// An object containing properties which are to be sent as parameters on any HTTP request
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    sortInfo: function Ext_data_JsonStoreConfig$sortInfo(value) {
        /// <summary>
        /// A config object in the format: {field: "fieldName", direction: "ASC|DESC"}.  The direction property is case-sensitive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['sortInfo'] = value;
        return this;
    },
    
    remoteSort: function Ext_data_JsonStoreConfig$remoteSort(value) {
        /// <summary>
        /// True if sorting is to be handled by requesting the Proxy to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to false). <p>If remote sorting is specified, then clicking on a column header causes the current page to be requested from the server with the addition of the following two parameters: <div class="mdetail-params"><ul><li><b>sort</b> : String<p class="sub-desc">The name (as specified in the Record's Field definition) of the field to sort on.</p></li><li><b>dir</b> : String<p class="sub-desc">The direction of the sort, "ASC" or "DESC" (case-sensitive).</p></li></ul></div></p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['remoteSort'] = value;
        return this;
    },
    
    pruneModifiedRecords: function Ext_data_JsonStoreConfig$pruneModifiedRecords(value) {
        /// <summary>
        /// True to clear all modified record information each time the store is loaded or when a record is removed. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['pruneModifiedRecords'] = value;
        return this;
    },
    
    listeners: function Ext_data_JsonStoreConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_JsonStoreConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.JsonStoreConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_JsonStoreConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.MemoryProxyConfig

Ext.data.MemoryProxyConfig = function Ext_data_MemoryProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.MemoryProxyConfig.prototype = {
    
    listeners: function Ext_data_MemoryProxyConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.MemoryProxyConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_MemoryProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.MemoryProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_MemoryProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.MemoryProxyEvents

Ext.data.MemoryProxyEvents = function Ext_data_MemoryProxyEvents() {
}
Ext.data.MemoryProxyEvents.get_loadexception = function Ext_data_MemoryProxyEvents$get_loadexception() {
    /// <summary>
    /// Fires if an exception occurs in the Proxy during data loading. Note that this event is also relayed
    /// through {@link Ext.data.Store}, so you can listen for it directly on any Store instance.
    /// <pre><code>
    /// USAGE: ({Object} objthis, {Object} arg, {Object} nul, {Error} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>arg</b></term><description>The callback's arg object passed to the {@link #load} function</description></item><item><term><b>nul</b></term><description>This parameter does not apply and will always be null for MemoryProxy</description></item><item><term><b>e</b></term><description>The JavaScript Error object caught if the configured Reader could not read the data</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'loadexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.NodeConfig

Ext.data.NodeConfig = function Ext_data_NodeConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.NodeConfig.prototype = {
    
    leaf: function Ext_data_NodeConfig$leaf(value) {
        /// <summary>
        /// true if this node is a leaf and does not have children
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.NodeConfig"></returns>
        this.o['leaf'] = value;
        return this;
    },
    
    id: function Ext_data_NodeConfig$id(value) {
        /// <summary>
        /// The id for this node. If one is not specified, one is generated.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.NodeConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    listeners: function Ext_data_NodeConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.NodeConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_NodeConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.NodeConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_NodeConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.NodeEvents

Ext.data.NodeEvents = function Ext_data_NodeEvents() {
}
Ext.data.NodeEvents.get_append = function Ext_data_NodeEvents$get_append() {
    /// <summary>
    /// Fires when a new child node is appended
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The newly appended node</description></item><item><term><b>index</b></term><description>The index of the newly appended node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'append';
}
Ext.data.NodeEvents.get_remove = function Ext_data_NodeEvents$get_remove() {
    /// <summary>
    /// Fires when a child node is removed
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The removed node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}
Ext.data.NodeEvents.get_move = function Ext_data_NodeEvents$get_move() {
    /// <summary>
    /// Fires when this node is moved to a new location in the tree
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>oldParent</b></term><description>The old parent of this node</description></item><item><term><b>newParent</b></term><description>The new parent of this node</description></item><item><term><b>index</b></term><description>The index it was moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'move';
}
Ext.data.NodeEvents.get_insert = function Ext_data_NodeEvents$get_insert() {
    /// <summary>
    /// Fires when a new child node is inserted.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The child node inserted</description></item><item><term><b>refNode</b></term><description>The child node the node was inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'insert';
}
Ext.data.NodeEvents.get_beforeappend = function Ext_data_NodeEvents$get_beforeappend() {
    /// <summary>
    /// Fires before a new child is appended, return false to cancel the append.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The child node to be appended</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeappend';
}
Ext.data.NodeEvents.get_beforeremove = function Ext_data_NodeEvents$get_beforeremove() {
    /// <summary>
    /// Fires before a child is removed, return false to cancel the remove.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The child node to be removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeremove';
}
Ext.data.NodeEvents.get_beforemove = function Ext_data_NodeEvents$get_beforemove() {
    /// <summary>
    /// Fires before this node is moved to a new location in the tree. Return false to cancel the move.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>oldParent</b></term><description>The parent of this node</description></item><item><term><b>newParent</b></term><description>The new parent this node is moving to</description></item><item><term><b>index</b></term><description>The index it is being moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforemove';
}
Ext.data.NodeEvents.get_beforeinsert = function Ext_data_NodeEvents$get_beforeinsert() {
    /// <summary>
    /// Fires before a new child is inserted, return false to cancel the insert.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} objthis, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>node</b></term><description>The child node to be inserted</description></item><item><term><b>refNode</b></term><description>The child node the node is being inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeinsert';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.RecordConfig

Ext.data.RecordConfig = function Ext_data_RecordConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.RecordConfig.prototype = {
    
    custom: function Ext_data_RecordConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.RecordConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_RecordConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.ScriptTagProxyConfig

Ext.data.ScriptTagProxyConfig = function Ext_data_ScriptTagProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.ScriptTagProxyConfig.prototype = {
    
    url: function Ext_data_ScriptTagProxyConfig$url(value) {
        /// <summary>
        /// The URL from which to request the data object.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    timeout: function Ext_data_ScriptTagProxyConfig$timeout(value) {
        /// <summary>
        /// (optional) The number of milliseconds to wait for a response. Defaults to 30 seconds.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    callbackParam: function Ext_data_ScriptTagProxyConfig$callbackParam(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o['callbackParam'] = value;
        return this;
    },
    
    nocache: function Ext_data_ScriptTagProxyConfig$nocache(value) {
        /// <summary>
        /// (optional) Defaults to true. Disable caching by adding a unique parameter name to the request.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o['nocache'] = value;
        return this;
    },
    
    listeners: function Ext_data_ScriptTagProxyConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_ScriptTagProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.ScriptTagProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_ScriptTagProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.ScriptTagProxyEvents

Ext.data.ScriptTagProxyEvents = function Ext_data_ScriptTagProxyEvents() {
}
Ext.data.ScriptTagProxyEvents.get_loadexception = function Ext_data_ScriptTagProxyEvents$get_loadexception() {
    /// <summary>
    /// Fires if an exception occurs in the Proxy during data loading.  This event can be fired for one of two reasons:
    /// <ul><li><b>The load call timed out.</b>  This means the load callback did not execute within the time limit
    /// specified by {@link #timeout}.  In this case, this event will be raised and the
    /// fourth parameter (read error) will be null.</li><li><b>The load succeeded but the reader could not read the response.</b>  This means the server returned
    /// data, but the configured Reader threw an error while reading the data.  In this case, this event will be
    /// raised and the caught error will be passed along as the fourth parameter of this event.</li></ul>
    /// Note that this event is also relayed through {@link Ext.data.Store}, so you can listen for it directly
    /// on any Store instance.
    /// call timed out, this parameter will be null.
    /// If the load call returned success: false, this parameter will be null.
    /// <pre><code>
    /// USAGE: ({Object} objthis, {Object} options, {Object} arg, {Error} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>options</b></term><description>The loading options that were specified (see {@link #load} for details).  If the load</description></item><item><term><b>arg</b></term><description>The callback's arg object passed to the {@link #load} function</description></item><item><term><b>e</b></term><description>The JavaScript Error object caught if the configured Reader could not read the data.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'loadexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.SimpleStoreConfig

Ext.data.SimpleStoreConfig = function Ext_data_SimpleStoreConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.SimpleStoreConfig.prototype = {
    
    id: function Ext_data_SimpleStoreConfig$id(value) {
        /// <summary>
        /// The array index of the record id. Leave blank to auto generate ids.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    fields: function Ext_data_SimpleStoreConfig$fields(value) {
        /// <summary>
        /// An array of field definition objects, or field name strings.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['fields'] = value;
        return this;
    },
    
    data: function Ext_data_SimpleStoreConfig$data(value) {
        /// <summary>
        /// The multi-dimensional array of data
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['data'] = value;
        return this;
    },
    
    storeId: function Ext_data_SimpleStoreConfig$storeId(value) {
        /// <summary>
        /// If passed, the id to use to register with the StoreMgr
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['storeId'] = value;
        return this;
    },
    
    url: function Ext_data_SimpleStoreConfig$url(value) {
        /// <summary>
        /// If passed, an HttpProxy is created for the passed URL
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    autoLoad: function Ext_data_SimpleStoreConfig$autoLoad(value) {
        /// <summary>
        /// {Boolean/Object} If passed, this store's load method is automatically called after creation with the autoLoad object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    proxy: function Ext_data_SimpleStoreConfig$proxy(value) {
        /// <summary>
        /// The Proxy object which provides access to a data object.
        /// </summary>
        /// <param name="value" type="Ext.data.DataProxy">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['proxy'] = value;
        return this;
    },
    
    reader: function Ext_data_SimpleStoreConfig$reader(value) {
        /// <summary>
        /// The DataReader object which processes the data object and returns an Array of Ext.data.Record objects which are cached keyed by their <em>id</em> property.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    baseParams: function Ext_data_SimpleStoreConfig$baseParams(value) {
        /// <summary>
        /// An object containing properties which are to be sent as parameters on any HTTP request
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    sortInfo: function Ext_data_SimpleStoreConfig$sortInfo(value) {
        /// <summary>
        /// A config object in the format: {field: "fieldName", direction: "ASC|DESC"}.  The direction property is case-sensitive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['sortInfo'] = value;
        return this;
    },
    
    remoteSort: function Ext_data_SimpleStoreConfig$remoteSort(value) {
        /// <summary>
        /// True if sorting is to be handled by requesting the Proxy to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to false). <p>If remote sorting is specified, then clicking on a column header causes the current page to be requested from the server with the addition of the following two parameters: <div class="mdetail-params"><ul><li><b>sort</b> : String<p class="sub-desc">The name (as specified in the Record's Field definition) of the field to sort on.</p></li><li><b>dir</b> : String<p class="sub-desc">The direction of the sort, "ASC" or "DESC" (case-sensitive).</p></li></ul></div></p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['remoteSort'] = value;
        return this;
    },
    
    pruneModifiedRecords: function Ext_data_SimpleStoreConfig$pruneModifiedRecords(value) {
        /// <summary>
        /// True to clear all modified record information each time the store is loaded or when a record is removed. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['pruneModifiedRecords'] = value;
        return this;
    },
    
    listeners: function Ext_data_SimpleStoreConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_SimpleStoreConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SimpleStoreConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_SimpleStoreConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.SortTypesConfig

Ext.data.SortTypesConfig = function Ext_data_SortTypesConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.SortTypesConfig.prototype = {
    
    custom: function Ext_data_SortTypesConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.SortTypesConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_SortTypesConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.StoreConfig

Ext.data.StoreConfig = function Ext_data_StoreConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.StoreConfig.prototype = {
    
    storeId: function Ext_data_StoreConfig$storeId(value) {
        /// <summary>
        /// If passed, the id to use to register with the StoreMgr
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['storeId'] = value;
        return this;
    },
    
    url: function Ext_data_StoreConfig$url(value) {
        /// <summary>
        /// If passed, an HttpProxy is created for the passed URL
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    autoLoad: function Ext_data_StoreConfig$autoLoad(value) {
        /// <summary>
        /// {Boolean/Object} If passed, this store's load method is automatically called after creation with the autoLoad object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    proxy: function Ext_data_StoreConfig$proxy(value) {
        /// <summary>
        /// The Proxy object which provides access to a data object.
        /// </summary>
        /// <param name="value" type="Ext.data.DataProxy">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['proxy'] = value;
        return this;
    },
    
    data: function Ext_data_StoreConfig$data(value) {
        /// <summary>
        /// Inline data to be loaded when the store is initialized.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['data'] = value;
        return this;
    },
    
    reader: function Ext_data_StoreConfig$reader(value) {
        /// <summary>
        /// The DataReader object which processes the data object and returns an Array of Ext.data.Record objects which are cached keyed by their <em>id</em> property.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    baseParams: function Ext_data_StoreConfig$baseParams(value) {
        /// <summary>
        /// An object containing properties which are to be sent as parameters on any HTTP request
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    sortInfo: function Ext_data_StoreConfig$sortInfo(value) {
        /// <summary>
        /// A config object in the format: {field: "fieldName", direction: "ASC|DESC"}.  The direction property is case-sensitive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['sortInfo'] = value;
        return this;
    },
    
    remoteSort: function Ext_data_StoreConfig$remoteSort(value) {
        /// <summary>
        /// True if sorting is to be handled by requesting the Proxy to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache in place (defaults to false). <p>If remote sorting is specified, then clicking on a column header causes the current page to be requested from the server with the addition of the following two parameters: <div class="mdetail-params"><ul><li><b>sort</b> : String<p class="sub-desc">The name (as specified in the Record's Field definition) of the field to sort on.</p></li><li><b>dir</b> : String<p class="sub-desc">The direction of the sort, "ASC" or "DESC" (case-sensitive).</p></li></ul></div></p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['remoteSort'] = value;
        return this;
    },
    
    pruneModifiedRecords: function Ext_data_StoreConfig$pruneModifiedRecords(value) {
        /// <summary>
        /// True to clear all modified record information each time the store is loaded or when a record is removed. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['pruneModifiedRecords'] = value;
        return this;
    },
    
    listeners: function Ext_data_StoreConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_StoreConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.StoreConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_StoreConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.StoreEvents

Ext.data.StoreEvents = function Ext_data_StoreEvents() {
}
Ext.data.StoreEvents.get_datachanged = function Ext_data_StoreEvents$get_datachanged() {
    /// <summary>
    /// Fires when the data cache has changed, and a widget which is using this Store
    /// as a Record cache should refresh its view.
    /// <pre><code>
    /// USAGE: ({Store} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'datachanged';
}
Ext.data.StoreEvents.get_metachange = function Ext_data_StoreEvents$get_metachange() {
    /// <summary>
    /// Fires when this store's reader provides new metadata (fields). This is currently only supported for JsonReaders.
    /// <pre><code>
    /// USAGE: ({Store} objthis, {Object} meta)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>meta</b></term><description>The JSON metadata</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'metachange';
}
Ext.data.StoreEvents.get_add = function Ext_data_StoreEvents$get_add() {
    /// <summary>
    /// Fires when Records have been added to the Store
    /// <pre><code>
    /// USAGE: ({Store} objthis, {Ext.data.Record[]} records, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>records</b></term><description>The array of Records added</description></item><item><term><b>index</b></term><description>The index at which the record(s) were added</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'add';
}
Ext.data.StoreEvents.get_remove = function Ext_data_StoreEvents$get_remove() {
    /// <summary>
    /// Fires when a Record has been removed from the Store
    /// <pre><code>
    /// USAGE: ({Store} objthis, {Ext.data.Record} record, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>record</b></term><description>The Record that was removed</description></item><item><term><b>index</b></term><description>The index at which the record was removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}
Ext.data.StoreEvents.get_update = function Ext_data_StoreEvents$get_update() {
    /// <summary>
    /// Fires when a Record has been updated
    /// <pre><code>
    /// Ext.data.Record.EDIT
    /// Ext.data.Record.REJECT
    /// Ext.data.Record.COMMIT
    /// </code></pre><pre><code>
    /// USAGE: ({Store} objthis, {Ext.data.Record} record, {String} operation)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>record</b></term><description>The Record that was updated</description></item><item><term><b>operation</b></term><description>The update operation being performed.  Value may be one of:</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'update';
}
Ext.data.StoreEvents.get_clear = function Ext_data_StoreEvents$get_clear() {
    /// <summary>
    /// Fires when the data cache has been cleared.
    /// <pre><code>
    /// USAGE: ({Store} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'clear';
}
Ext.data.StoreEvents.get_beforeload = function Ext_data_StoreEvents$get_beforeload() {
    /// <summary>
    /// Fires before a request is made for a new data object.  If the beforeload handler returns false
    /// the load action will be canceled.
    /// <pre><code>
    /// USAGE: ({Store} objthis, {Object} options)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>options</b></term><description>The loading options that were specified (see {@link #load} for details)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeload';
}
Ext.data.StoreEvents.get_load = function Ext_data_StoreEvents$get_load() {
    /// <summary>
    /// Fires after a new set of Records has been loaded.
    /// <pre><code>
    /// USAGE: ({Store} objthis, {Ext.data.Record[]} records, {Object} options)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>records</b></term><description>The Records that were loaded</description></item><item><term><b>options</b></term><description>The loading options that were specified (see {@link #load} for details)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'load';
}
Ext.data.StoreEvents.get_loadexception = function Ext_data_StoreEvents$get_loadexception() {
    /// <summary>
    /// Fires if an exception occurs in the Proxy during loading.
    /// Called with the signature of the Proxy's "loadexception" event.
    /// <pre><code>
    /// USAGE: ()
    /// </code></pre><list type="bullet"></list>
    /// </summary>
    /// <value type="String"></value>
    return 'loadexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.TreeConfig

Ext.data.TreeConfig = function Ext_data_TreeConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.TreeConfig.prototype = {
    
    pathSeparator: function Ext_data_TreeConfig$pathSeparator(value) {
        /// <summary>
        /// The token used to separate paths in node ids (defaults to '/').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.TreeConfig"></returns>
        this.o['pathSeparator'] = value;
        return this;
    },
    
    listeners: function Ext_data_TreeConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.TreeConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_data_TreeConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.TreeConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_TreeConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.TreeEvents

Ext.data.TreeEvents = function Ext_data_TreeEvents() {
}
Ext.data.TreeEvents.get_append = function Ext_data_TreeEvents$get_append() {
    /// <summary>
    /// Fires when a new child node is appended to a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The newly appended node</description></item><item><term><b>index</b></term><description>The index of the newly appended node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'append';
}
Ext.data.TreeEvents.get_remove = function Ext_data_TreeEvents$get_remove() {
    /// <summary>
    /// Fires when a child node is removed from a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}
Ext.data.TreeEvents.get_move = function Ext_data_TreeEvents$get_move() {
    /// <summary>
    /// Fires when a node is moved to a new location in the tree
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} node, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>node</b></term><description>The node moved</description></item><item><term><b>oldParent</b></term><description>The old parent of this node</description></item><item><term><b>newParent</b></term><description>The new parent of this node</description></item><item><term><b>index</b></term><description>The index it was moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'move';
}
Ext.data.TreeEvents.get_insert = function Ext_data_TreeEvents$get_insert() {
    /// <summary>
    /// Fires when a new child node is inserted in a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node inserted</description></item><item><term><b>refNode</b></term><description>The child node the node was inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'insert';
}
Ext.data.TreeEvents.get_beforeappend = function Ext_data_TreeEvents$get_beforeappend() {
    /// <summary>
    /// Fires before a new child is appended to a node in this tree, return false to cancel the append.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be appended</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeappend';
}
Ext.data.TreeEvents.get_beforeremove = function Ext_data_TreeEvents$get_beforeremove() {
    /// <summary>
    /// Fires before a child is removed from a node in this tree, return false to cancel the remove.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeremove';
}
Ext.data.TreeEvents.get_beforemove = function Ext_data_TreeEvents$get_beforemove() {
    /// <summary>
    /// Fires before a node is moved to a new location in the tree. Return false to cancel the move.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} node, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>node</b></term><description>The node being moved</description></item><item><term><b>oldParent</b></term><description>The parent of the node</description></item><item><term><b>newParent</b></term><description>The new parent the node is moving to</description></item><item><term><b>index</b></term><description>The index it is being moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforemove';
}
Ext.data.TreeEvents.get_beforeinsert = function Ext_data_TreeEvents$get_beforeinsert() {
    /// <summary>
    /// Fires before a new child is inserted in a node in this tree, return false to cancel the insert.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be inserted</description></item><item><term><b>refNode</b></term><description>The child node the node is being inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeinsert';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.data.XmlReaderConfig

Ext.data.XmlReaderConfig = function Ext_data_XmlReaderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.data.XmlReaderConfig.prototype = {
    
    totalRecords: function Ext_data_XmlReaderConfig$totalRecords(value) {
        /// <summary>
        /// The DomQuery path from which to retrieve the total number of records
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.XmlReaderConfig"></returns>
        this.o['totalRecords'] = value;
        return this;
    },
    
    record: function Ext_data_XmlReaderConfig$record(value) {
        /// <summary>
        /// The DomQuery path to the repeated element which contains record information.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.XmlReaderConfig"></returns>
        this.o['record'] = value;
        return this;
    },
    
    success: function Ext_data_XmlReaderConfig$success(value) {
        /// <summary>
        /// The DomQuery path to the success attribute used by forms.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.XmlReaderConfig"></returns>
        this.o['success'] = value;
        return this;
    },
    
    id: function Ext_data_XmlReaderConfig$id(value) {
        /// <summary>
        /// The DomQuery path relative from the record element to the element that contains
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.data.XmlReaderConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    custom: function Ext_data_XmlReaderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.data.XmlReaderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_data_XmlReaderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.dd');

////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DDConfig

Ext.dd.DDConfig = function Ext_dd_DDConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DDConfig.prototype = {
    
    custom: function Ext_dd_DDConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DDConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DDConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DDProxyConfig

Ext.dd.DDProxyConfig = function Ext_dd_DDProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DDProxyConfig.prototype = {
    
    custom: function Ext_dd_DDProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DDProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DDProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DDTargetConfig

Ext.dd.DDTargetConfig = function Ext_dd_DDTargetConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DDTargetConfig.prototype = {
    
    custom: function Ext_dd_DDTargetConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DDTargetConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DDTargetConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DragDropConfig

Ext.dd.DragDropConfig = function Ext_dd_DragDropConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DragDropConfig.prototype = {
    
    custom: function Ext_dd_DragDropConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DragDropConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DragDropConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DragDropMgrConfig

Ext.dd.DragDropMgrConfig = function Ext_dd_DragDropMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DragDropMgrConfig.prototype = {
    
    custom: function Ext_dd_DragDropMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DragDropMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DragDropMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DragSourceConfig

Ext.dd.DragSourceConfig = function Ext_dd_DragSourceConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DragSourceConfig.prototype = {
    
    ddGroup: function Ext_dd_DragSourceConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to undefined).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragSourceConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    dropAllowed: function Ext_dd_DragSourceConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragSourceConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_dd_DragSourceConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragSourceConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_dd_DragSourceConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DragSourceConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DragSourceConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DragZoneConfig

Ext.dd.DragZoneConfig = function Ext_dd_DragZoneConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DragZoneConfig.prototype = {
    
    containerScroll: function Ext_dd_DragZoneConfig$containerScroll(value) {
        /// <summary>
        /// True to register this container with the Scrollmanager for auto scrolling during drag operations.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o['containerScroll'] = value;
        return this;
    },
    
    hlColor: function Ext_dd_DragZoneConfig$hlColor(value) {
        /// <summary>
        /// The color to use when visually highlighting the drag source in the afterRepair method after a failed drop (defaults to "c3daf9" - light blue)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o['hlColor'] = value;
        return this;
    },
    
    ddGroup: function Ext_dd_DragZoneConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to undefined).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    dropAllowed: function Ext_dd_DragZoneConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_dd_DragZoneConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_dd_DragZoneConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DragZoneConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DragZoneConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DropTargetConfig

Ext.dd.DropTargetConfig = function Ext_dd_DropTargetConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DropTargetConfig.prototype = {
    
    ddGroup: function Ext_dd_DropTargetConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to undefined).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropTargetConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    overClass: function Ext_dd_DropTargetConfig$overClass(value) {
        /// <summary>
        /// The CSS class applied to the drop target element while the drag source is over it (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropTargetConfig"></returns>
        this.o['overClass'] = value;
        return this;
    },
    
    dropAllowed: function Ext_dd_DropTargetConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropTargetConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_dd_DropTargetConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropTargetConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_dd_DropTargetConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DropTargetConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DropTargetConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.DropZoneConfig

Ext.dd.DropZoneConfig = function Ext_dd_DropZoneConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.DropZoneConfig.prototype = {
    
    ddGroup: function Ext_dd_DropZoneConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to undefined).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropZoneConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    overClass: function Ext_dd_DropZoneConfig$overClass(value) {
        /// <summary>
        /// The CSS class applied to the drop target element while the drag source is over it (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropZoneConfig"></returns>
        this.o['overClass'] = value;
        return this;
    },
    
    dropAllowed: function Ext_dd_DropZoneConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropZoneConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_dd_DropZoneConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.DropZoneConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_dd_DropZoneConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.DropZoneConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_DropZoneConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.RegistryConfig

Ext.dd.RegistryConfig = function Ext_dd_RegistryConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.RegistryConfig.prototype = {
    
    custom: function Ext_dd_RegistryConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.RegistryConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_RegistryConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.ScrollManagerConfig

Ext.dd.ScrollManagerConfig = function Ext_dd_ScrollManagerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.ScrollManagerConfig.prototype = {
    
    custom: function Ext_dd_ScrollManagerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.ScrollManagerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_ScrollManagerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.dd.StatusProxyConfig

Ext.dd.StatusProxyConfig = function Ext_dd_StatusProxyConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.dd.StatusProxyConfig.prototype = {
    
    dropAllowed: function Ext_dd_StatusProxyConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class to apply to the status element when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.StatusProxyConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_dd_StatusProxyConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class to apply to the status element when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.dd.StatusProxyConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_dd_StatusProxyConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.dd.StatusProxyConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_dd_StatusProxyConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.form');

////////////////////////////////////////////////////////////////////////////////
// Ext.form.ActionConfig

Ext.form.ActionConfig = function Ext_form_ActionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.ActionConfig.prototype = {
    
    url: function Ext_form_ActionConfig$url(value) {
        /// <summary>
        /// The URL that the Action is to invoke.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    method: function Ext_form_ActionConfig$method(value) {
        /// <summary>
        /// The HTTP method to use to access the requested URL. Defaults to the {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    params_: function Ext_form_ActionConfig$params_(value) {
        /// <summary>
        /// Extra parameter values to pass. These are added to the Form's {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's input fields.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['params'] = value;
        return this;
    },
    
    timeout: function Ext_form_ActionConfig$timeout(value) {
        /// <summary>
        /// The number of milliseconds to wait for a server response before failing with the {@link #failureType} as {@link #CONNECT_FAILURE}.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    success: function Ext_form_ActionConfig$success(value) {
        /// <summary>
        /// The function to call when a valid success return packet is recieved. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['success'] = value;
        return this;
    },
    
    failure: function Ext_form_ActionConfig$failure(value) {
        /// <summary>
        /// The function to call when a failure packet was recieved, or when an error ocurred in the Ajax communication. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. If an Ajax error ocurred, the failure type will be in {@link #failureType}. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['failure'] = value;
        return this;
    },
    
    scope: function Ext_form_ActionConfig$scope(value) {
        /// <summary>
        /// The scope in which to call the callback functions (The <tt>this</tt> reference for the callback functions).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    waitMsg: function Ext_form_ActionConfig$waitMsg(value) {
        /// <summary>
        /// The message to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['waitMsg'] = value;
        return this;
    },
    
    waitTitle: function Ext_form_ActionConfig$waitTitle(value) {
        /// <summary>
        /// The title to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o['waitTitle'] = value;
        return this;
    },
    
    custom: function Ext_form_ActionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ActionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_ActionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.BasicFormConfig

Ext.form.BasicFormConfig = function Ext_form_BasicFormConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.BasicFormConfig.prototype = {
    
    method: function Ext_form_BasicFormConfig$method(value) {
        /// <summary>
        /// The request method to use (GET or POST) for form actions if one isn't supplied in the action options.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    reader: function Ext_form_BasicFormConfig$reader(value) {
        /// <summary>
        /// An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to read data when executing "load" actions. This is optional as there is built-in support for processing JSON.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    errorReader: function Ext_form_BasicFormConfig$errorReader(value) {
        /// <summary>
        /// An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to read data when reading validation errors on "submit" actions. This is completely optional as there is built-in support for processing JSON.
        /// </summary>
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['errorReader'] = value;
        return this;
    },
    
    url: function Ext_form_BasicFormConfig$url(value) {
        /// <summary>
        /// The URL to use for form actions if one isn't supplied in the action options.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    fileUpload: function Ext_form_BasicFormConfig$fileUpload(value) {
        /// <summary>
        /// Set to true if this form is a file upload. <p>File uploads are not performed using normal "Ajax" techniques, that is they are <b>not</b> performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the DOM <tt>&lt;form&gt;</tt> element temporarily modified to have its {@link http://www.w3.org/TR/REC-html40/present/frames.html#adef-target target} set to refer to a dynamically generated, hidden <tt>&lt;iframe&gt;</tt> which is inserted into the document but removed after the return data has been gathered.</p><p>The server response is parsed by the browser to create the document for the IFRAME. If the server is using JSON to send the return object, then the {@link http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17 Content-Type} header must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.</p><p>The response text is retrieved from the document, and a fake XMLHttpRequest object is created containing a <tt>responseText</tt> property in order to conform to the requirements of event handlers and callbacks.</p><p>Be aware that file upload packets are sent with the content type {@link http://www.faqs.org/rfcs/rfc2388.html multipart/form} and some server technologies (notably JEE) may require some custom processing in order to retrieve parameter names and parameter values from the packet content.</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['fileUpload'] = value;
        return this;
    },
    
    baseParams: function Ext_form_BasicFormConfig$baseParams(value) {
        /// <summary>
        /// Parameters to pass with all requests. e.g. baseParams: {id: '123', foo: 'bar'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    timeout: function Ext_form_BasicFormConfig$timeout(value) {
        /// <summary>
        /// Timeout for form actions in seconds (default is 30 seconds).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    trackResetOnLoad: function Ext_form_BasicFormConfig$trackResetOnLoad(value) {
        /// <summary>
        /// If set to true, form.reset() resets to the last loaded or setValues() data instead of when the form was first created.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['trackResetOnLoad'] = value;
        return this;
    },
    
    standardSubmit: function Ext_form_BasicFormConfig$standardSubmit(value) {
        /// <summary>
        /// If set to true, standard HTML form submits are used instead of XHR (Ajax) style form submissions. (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['standardSubmit'] = value;
        return this;
    },
    
    listeners: function Ext_form_BasicFormConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_BasicFormConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.BasicFormConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_BasicFormConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.BasicFormEvents

Ext.form.BasicFormEvents = function Ext_form_BasicFormEvents() {
}
Ext.form.BasicFormEvents.get_beforeaction = function Ext_form_BasicFormEvents$get_beforeaction() {
    /// <summary>
    /// Fires before any action is performed. Return false to cancel the action.
    /// <pre><code>
    /// USAGE: ({Form} objthis, {Action} action)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>action</b></term><description>The {@link Ext.form.Action} to be performed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeaction';
}
Ext.form.BasicFormEvents.get_actionfailed = function Ext_form_BasicFormEvents$get_actionfailed() {
    /// <summary>
    /// Fires when an action fails.
    /// <pre><code>
    /// USAGE: ({Form} objthis, {Action} action)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>action</b></term><description>The {@link Ext.form.Action} that failed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'actionfailed';
}
Ext.form.BasicFormEvents.get_actioncomplete = function Ext_form_BasicFormEvents$get_actioncomplete() {
    /// <summary>
    /// Fires when an action is completed.
    /// <pre><code>
    /// USAGE: ({Form} objthis, {Action} action)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>action</b></term><description>The {@link Ext.form.Action} that completed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'actioncomplete';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.CheckboxConfig

Ext.form.CheckboxConfig = function Ext_form_CheckboxConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.CheckboxConfig.prototype = {
    
    focusClass: function Ext_form_CheckboxConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the checkbox receives focus (defaults to undefined)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_CheckboxConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the checkbox (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    checked_: function Ext_form_CheckboxConfig$checked_(value) {
        /// <summary>
        /// True if the the checkbox should render already checked (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['checked'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_CheckboxConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "checkbox", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    boxLabel: function Ext_form_CheckboxConfig$boxLabel(value) {
        /// <summary>
        /// The text that appears beside the checkbox
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['boxLabel'] = value;
        return this;
    },
    
    inputValue: function Ext_form_CheckboxConfig$inputValue(value) {
        /// <summary>
        /// The value that should go into the generated input element's value attribute
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['inputValue'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_CheckboxConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_CheckboxConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_CheckboxConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_CheckboxConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_CheckboxConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_CheckboxConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_CheckboxConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_CheckboxConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_CheckboxConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_CheckboxConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_CheckboxConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_CheckboxConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_CheckboxConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_CheckboxConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_CheckboxConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_CheckboxConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_CheckboxConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_CheckboxConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_CheckboxConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_CheckboxConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_CheckboxConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_CheckboxConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_CheckboxConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_CheckboxConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_CheckboxConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_CheckboxConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_CheckboxConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_CheckboxConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_CheckboxConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_CheckboxConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_CheckboxConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_CheckboxConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_CheckboxConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_CheckboxConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_CheckboxConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_CheckboxConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_CheckboxConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_CheckboxConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_CheckboxConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_CheckboxConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_CheckboxConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_CheckboxConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_CheckboxConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_CheckboxConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_CheckboxConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_CheckboxConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.CheckboxConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_CheckboxConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.CheckboxEvents

Ext.form.CheckboxEvents = function Ext_form_CheckboxEvents() {
}
Ext.form.CheckboxEvents.get_check = function Ext_form_CheckboxEvents$get_check() {
    /// <summary>
    /// Fires when the checkbox is checked or unchecked.
    /// <pre><code>
    /// USAGE: ({Ext.form.Checkbox} objthis, {Boolean} chckd)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This checkbox</description></item><item><term><b>chckd</b></term><description>The new checked value</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'check';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.ComboBoxConfig

Ext.form.ComboBoxConfig = function Ext_form_ComboBoxConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.ComboBoxConfig.prototype = {
    
    transform: function Ext_form_ComboBoxConfig$transform(value) {
        /// <summary>
        /// The id, DOM node or element of an existing HTML SELECT to convert to a ComboBox. Note that if you specify this and the combo is going to be in a {@link Ext.form.BasicForm} or {@link Ext.form.FormPanel}, you must also set {@link #lazyRender} = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['transform'] = value;
        return this;
    },
    
    lazyRender: function Ext_form_ComboBoxConfig$lazyRender(value) {
        /// <summary>
        /// True to prevent the ComboBox from rendering until requested (should always be used when rendering into an Ext.Editor, defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['lazyRender'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_ComboBoxConfig$autoCreate(value) {
        /// <summary>
        /// {Boolean/Object} A DomHelper element spec, or true for a default element spec (defaults to: {tag: "input", type: "text", size: "24", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    store: function Ext_form_ComboBoxConfig$store(value) {
        /// <summary>
        /// {Ext.data.Store/Array} The data source to which this combo is bound (defaults to undefined).  This can be any {@link Ext.data.Store} subclass, a 1-dimensional array (e.g., ['Foo','Bar']) or a 2-dimensional array (e.g., [['f','Foo'],['b','Bar']]).  Arrays will be converted to a {@link Ext.data.SimpleStore} internally. 1-dimensional arrays will automatically be expanded (each array item will be the combo value and text) and for multi-dimensional arrays, the value in index 0 of each item will be assumed to be the combo value, while the value at index 1 is assumed to be the combo text.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    title: function Ext_form_ComboBoxConfig$title(value) {
        /// <summary>
        /// If supplied, a header element is created containing this text and added into the top of the dropdown list (defaults to undefined, with no header element)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    listWidth: function Ext_form_ComboBoxConfig$listWidth(value) {
        /// <summary>
        /// The width in pixels of the dropdown list (defaults to the width of the ComboBox field)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['listWidth'] = value;
        return this;
    },
    
    displayField: function Ext_form_ComboBoxConfig$displayField(value) {
        /// <summary>
        /// The underlying data field name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'text' if transforming a select)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['displayField'] = value;
        return this;
    },
    
    valueField: function Ext_form_ComboBoxConfig$valueField(value) {
        /// <summary>
        /// The underlying data value name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'value' if transforming a select) Note: use of a valueField requires the user to make a selection in order for a value to be mapped.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['valueField'] = value;
        return this;
    },
    
    hiddenName: function Ext_form_ComboBoxConfig$hiddenName(value) {
        /// <summary>
        /// If specified, a hidden form field with this name is dynamically generated to store the field's data value (defaults to the underlying DOM element's name). Required for the combo's value to automatically post during a form submission.  Note that the hidden field's id will also default to this name if {@link #hiddenId} is not specified.  The combo's id and the hidden field's ids should be different, since no two DOM nodes should share the same id, so if the combo and hidden names are the same, you should specify a unique hiddenId.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hiddenName'] = value;
        return this;
    },
    
    hiddenId: function Ext_form_ComboBoxConfig$hiddenId(value) {
        /// <summary>
        /// If {@link #hiddenName} is specified, hiddenId can also be provided to give the hidden field a unique id (defaults to the hiddenName).  The hiddenId and combo {@link #id} should be different, since no two DOM nodes should share the same id.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hiddenId'] = value;
        return this;
    },
    
    listClass: function Ext_form_ComboBoxConfig$listClass(value) {
        /// <summary>
        /// CSS class to apply to the dropdown list element (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['listClass'] = value;
        return this;
    },
    
    selectedClass: function Ext_form_ComboBoxConfig$selectedClass(value) {
        /// <summary>
        /// CSS class to apply to the selected item in the dropdown list (defaults to 'x-combo-selected')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['selectedClass'] = value;
        return this;
    },
    
    triggerClass: function Ext_form_ComboBoxConfig$triggerClass(value) {
        /// <summary>
        /// An additional CSS class used to style the trigger button.  The trigger will always get the class 'x-form-trigger' and triggerClass will be <b>appended</b> if specified (defaults to 'x-form-arrow-trigger' which displays a downward arrow icon).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['triggerClass'] = value;
        return this;
    },
    
    shadow: function Ext_form_ComboBoxConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    listAlign: function Ext_form_ComboBoxConfig$listAlign(value) {
        /// <summary>
        /// A valid anchor position value. See {@link Ext.Element#alignTo} for details on supported anchor positions (defaults to 'tl-bl')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['listAlign'] = value;
        return this;
    },
    
    maxHeight: function Ext_form_ComboBoxConfig$maxHeight(value) {
        /// <summary>
        /// The maximum height in pixels of the dropdown list before scrollbars are shown (defaults to 300)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    minHeight: function Ext_form_ComboBoxConfig$minHeight(value) {
        /// <summary>
        /// The minimum height in pixels of the dropdown list when the list is constrained by its distance to the viewport edges (defaults to 90)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    triggerAction: function Ext_form_ComboBoxConfig$triggerAction(value) {
        /// <summary>
        /// The action to execute when the trigger field is activated.  Use 'all' to run the query specified by the allQuery config option (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['triggerAction'] = value;
        return this;
    },
    
    minChars: function Ext_form_ComboBoxConfig$minChars(value) {
        /// <summary>
        /// The minimum number of characters the user must type before autocomplete and typeahead activate (defaults to 4 if remote or 0 if local, does not apply if editable = false)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['minChars'] = value;
        return this;
    },
    
    typeAhead: function Ext_form_ComboBoxConfig$typeAhead(value) {
        /// <summary>
        /// True to populate and autoselect the remainder of the text being typed after a configurable delay ({@link #typeAheadDelay}) if it matches a known value (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['typeAhead'] = value;
        return this;
    },
    
    queryDelay: function Ext_form_ComboBoxConfig$queryDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown list (defaults to 500 if mode = 'remote' or 10 if mode = 'local')
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['queryDelay'] = value;
        return this;
    },
    
    pageSize: function Ext_form_ComboBoxConfig$pageSize(value) {
        /// <summary>
        /// If greater than 0, a paging toolbar is displayed in the footer of the dropdown list and the filter queries will execute with page start and limit parameters.  Only applies when mode = 'remote' (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['pageSize'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_ComboBoxConfig$selectOnFocus(value) {
        /// <summary>
        /// True to select any existing text in the field immediately on focus.  Only applies when editable = true (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    queryParam: function Ext_form_ComboBoxConfig$queryParam(value) {
        /// <summary>
        /// Name of the query as it will be passed on the querystring (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['queryParam'] = value;
        return this;
    },
    
    loadingText: function Ext_form_ComboBoxConfig$loadingText(value) {
        /// <summary>
        /// The text to display in the dropdown list while data is loading.  Only applies when mode = 'remote' (defaults to 'Loading...')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['loadingText'] = value;
        return this;
    },
    
    resizable: function Ext_form_ComboBoxConfig$resizable(value) {
        /// <summary>
        /// True to add a resize handle to the bottom of the dropdown list (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    handleHeight: function Ext_form_ComboBoxConfig$handleHeight(value) {
        /// <summary>
        /// The height in pixels of the dropdown list resize handle if resizable = true (defaults to 8)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['handleHeight'] = value;
        return this;
    },
    
    editable: function Ext_form_ComboBoxConfig$editable(value) {
        /// <summary>
        /// False to prevent the user from typing text directly into the field, just like a traditional select (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['editable'] = value;
        return this;
    },
    
    allQuery: function Ext_form_ComboBoxConfig$allQuery(value) {
        /// <summary>
        /// The text query to send to the server to return all records for the list with no filtering (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['allQuery'] = value;
        return this;
    },
    
    mode: function Ext_form_ComboBoxConfig$mode(value) {
        /// <summary>
        /// Set to 'local' if the ComboBox loads local data (defaults to 'remote' which loads from the server)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['mode'] = value;
        return this;
    },
    
    minListWidth: function Ext_form_ComboBoxConfig$minListWidth(value) {
        /// <summary>
        /// The minimum width of the dropdown list in pixels (defaults to 70, will be ignored if listWidth has a higher value)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['minListWidth'] = value;
        return this;
    },
    
    forceSelection: function Ext_form_ComboBoxConfig$forceSelection(value) {
        /// <summary>
        /// True to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text into the field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['forceSelection'] = value;
        return this;
    },
    
    typeAheadDelay: function Ext_form_ComboBoxConfig$typeAheadDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['typeAheadDelay'] = value;
        return this;
    },
    
    valueNotFoundText: function Ext_form_ComboBoxConfig$valueNotFoundText(value) {
        /// <summary>
        /// When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be displayed as the field text if defined (defaults to undefined). If this defaut text is used, it means there is no value set and no validation will occur on this field.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['valueNotFoundText'] = value;
        return this;
    },
    
    lazyInit: function Ext_form_ComboBoxConfig$lazyInit(value) {
        /// <summary>
        /// True to not initialize the list for this combo until the field is focused (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['lazyInit'] = value;
        return this;
    },
    
    tpl: function Ext_form_ComboBoxConfig$tpl(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['tpl'] = value;
        return this;
    },
    
    itemSelector: function Ext_form_ComboBoxConfig$itemSelector(value) {
        /// <summary>
        /// <b>This setting is required if a custom XTemplate has been specified in {@link #tpl} which assigns a class other than <pre>'x-combo-list-item'</pre> to dropdown list items</b>. A simple CSS selector (e.g. div.some-class or span:first-child) that will be used to determine what nodes the DataView which handles the dropdown display will be working with.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['itemSelector'] = value;
        return this;
    },
    
    hideTrigger: function Ext_form_ComboBoxConfig$hideTrigger(value) {
        /// <summary>
        /// True to hide the trigger element and display only the base text field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hideTrigger'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_ComboBoxConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_ComboBoxConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_ComboBoxConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_ComboBoxConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_ComboBoxConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_ComboBoxConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_ComboBoxConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_ComboBoxConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_ComboBoxConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_ComboBoxConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_ComboBoxConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_ComboBoxConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    blankText: function Ext_form_ComboBoxConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_ComboBoxConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_ComboBoxConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_ComboBoxConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_ComboBoxConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_ComboBoxConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_ComboBoxConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_ComboBoxConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_ComboBoxConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_ComboBoxConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_ComboBoxConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_ComboBoxConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_ComboBoxConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_ComboBoxConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_ComboBoxConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_ComboBoxConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_ComboBoxConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_ComboBoxConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_ComboBoxConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_ComboBoxConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_ComboBoxConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_ComboBoxConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_ComboBoxConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_ComboBoxConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_ComboBoxConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_ComboBoxConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_ComboBoxConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_ComboBoxConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_ComboBoxConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_ComboBoxConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_ComboBoxConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_ComboBoxConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_ComboBoxConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_ComboBoxConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_ComboBoxConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_ComboBoxConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_ComboBoxConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_ComboBoxConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_ComboBoxConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_ComboBoxConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_ComboBoxConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_ComboBoxConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_ComboBoxConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_ComboBoxConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_ComboBoxConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_ComboBoxConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_ComboBoxConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_ComboBoxConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_ComboBoxConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_ComboBoxConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_ComboBoxConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_ComboBoxConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_ComboBoxConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_ComboBoxConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_ComboBoxConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.ComboBoxConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_ComboBoxConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.ComboBoxEvents

Ext.form.ComboBoxEvents = function Ext_form_ComboBoxEvents() {
}
Ext.form.ComboBoxEvents.get_expand = function Ext_form_ComboBoxEvents$get_expand() {
    /// <summary>
    /// Fires when the dropdown list is expanded
    /// <pre><code>
    /// USAGE: ({Ext.form.ComboBox} combo)
    /// </code></pre><list type="bullet"><item><term><b>combo</b></term><description>This combo box</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'expand';
}
Ext.form.ComboBoxEvents.get_collapse = function Ext_form_ComboBoxEvents$get_collapse() {
    /// <summary>
    /// Fires when the dropdown list is collapsed
    /// <pre><code>
    /// USAGE: ({Ext.form.ComboBox} combo)
    /// </code></pre><list type="bullet"><item><term><b>combo</b></term><description>This combo box</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'collapse';
}
Ext.form.ComboBoxEvents.get_beforeselect = function Ext_form_ComboBoxEvents$get_beforeselect() {
    /// <summary>
    /// Fires before a list item is selected. Return false to cancel the selection.
    /// <pre><code>
    /// USAGE: ({Ext.form.ComboBox} combo, {Ext.data.Record} record, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>combo</b></term><description>This combo box</description></item><item><term><b>record</b></term><description>The data record returned from the underlying store</description></item><item><term><b>index</b></term><description>The index of the selected item in the dropdown list</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeselect';
}
Ext.form.ComboBoxEvents.get_select = function Ext_form_ComboBoxEvents$get_select() {
    /// <summary>
    /// Fires when a list item is selected
    /// <pre><code>
    /// USAGE: ({Ext.form.ComboBox} combo, {Ext.data.Record} record, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>combo</b></term><description>This combo box</description></item><item><term><b>record</b></term><description>The data record returned from the underlying store</description></item><item><term><b>index</b></term><description>The index of the selected item in the dropdown list</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'select';
}
Ext.form.ComboBoxEvents.get_beforequery = function Ext_form_ComboBoxEvents$get_beforequery() {
    /// <value type="String"></value>
    return 'beforequery';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.DateFieldConfig

Ext.form.DateFieldConfig = function Ext_form_DateFieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.DateFieldConfig.prototype = {
    
    format: function Ext_form_DateFieldConfig$format(value) {
        /// <summary>
        /// The default date format string which can be overriden for localization support.  The format must be valid according to {@link Date#parseDate} (defaults to 'm/d/Y').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['format'] = value;
        return this;
    },
    
    altFormats: function Ext_form_DateFieldConfig$altFormats(value) {
        /// <summary>
        /// Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined format (defaults to 'm/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['altFormats'] = value;
        return this;
    },
    
    disabledDays: function Ext_form_DateFieldConfig$disabledDays(value) {
        /// <summary>
        /// An array of days to disable, 0 based. For example, [0, 6] disables Sunday and Saturday (defaults to null).
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabledDays'] = value;
        return this;
    },
    
    disabledDaysText: function Ext_form_DateFieldConfig$disabledDaysText(value) {
        /// <summary>
        /// The tooltip to display when the date falls on a disabled day (defaults to 'Disabled')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabledDaysText'] = value;
        return this;
    },
    
    disabledDates: function Ext_form_DateFieldConfig$disabledDates(value) {
        /// <summary>
        /// An array of "dates" to disable, as strings. These strings will be used to build a dynamic regular expression so they are very powerful. Some examples: <ul><li>["03/08/2003", "09/16/2003"] would disable those exact dates</li><li>["03/08", "09/16"] would disable those days for every year</li><li>["^03/08"] would only match the beginning (useful if you are using short years)</li><li>["03/../2006"] would disable every day in March 2006</li><li>["^03"] would disable every day in every March</li></ul> In order to support regular expressions, if you are using a date format that has "." in it, you will have to escape the dot when restricting dates. For example: ["03\\.08\\.03"].
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabledDates'] = value;
        return this;
    },
    
    disabledDatesText: function Ext_form_DateFieldConfig$disabledDatesText(value) {
        /// <summary>
        /// The tooltip text to display when the date falls on a disabled date (defaults to 'Disabled')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabledDatesText'] = value;
        return this;
    },
    
    minValue: function Ext_form_DateFieldConfig$minValue(value) {
        /// <summary>
        /// {Date/String}  The minimum allowed date. Can be either a Javascript date object or a string date in a valid format (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['minValue'] = value;
        return this;
    },
    
    maxValue: function Ext_form_DateFieldConfig$maxValue(value) {
        /// <summary>
        /// {Date/String}  The maximum allowed date. Can be either a Javascript date object or a string date in a valid format (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['maxValue'] = value;
        return this;
    },
    
    minText: function Ext_form_DateFieldConfig$minText(value) {
        /// <summary>
        /// The error text to display when the date in the cell is before minValue (defaults to 'The date in this field must be after {minValue}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['minText'] = value;
        return this;
    },
    
    maxText: function Ext_form_DateFieldConfig$maxText(value) {
        /// <summary>
        /// The error text to display when the date in the cell is after maxValue (defaults to 'The date in this field must be before {maxValue}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['maxText'] = value;
        return this;
    },
    
    invalidText: function Ext_form_DateFieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to display when the date in the field is invalid (defaults to '{value} is not a valid date - it must be in the format {format}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    triggerClass: function Ext_form_DateFieldConfig$triggerClass(value) {
        /// <summary>
        /// An additional CSS class used to style the trigger button.  The trigger will always get the class 'x-form-trigger' and triggerClass will be <b>appended</b> if specified (defaults to 'x-form-date-trigger' which displays a calendar icon).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['triggerClass'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_DateFieldConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object}  A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "10", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    hideTrigger: function Ext_form_DateFieldConfig$hideTrigger(value) {
        /// <summary>
        /// True to hide the trigger element and display only the base text field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['hideTrigger'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_DateFieldConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_DateFieldConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_DateFieldConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_DateFieldConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_DateFieldConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_DateFieldConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_DateFieldConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_DateFieldConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_DateFieldConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_DateFieldConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_DateFieldConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_DateFieldConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_DateFieldConfig$selectOnFocus(value) {
        /// <summary>
        /// True to automatically select any existing field text when the field receives input focus (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    blankText: function Ext_form_DateFieldConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_DateFieldConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_DateFieldConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_DateFieldConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_DateFieldConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_DateFieldConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_DateFieldConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_DateFieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_DateFieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_DateFieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_DateFieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_DateFieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_DateFieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_DateFieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_DateFieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_DateFieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_DateFieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_DateFieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_DateFieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    focusClass: function Ext_form_DateFieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_DateFieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_DateFieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_DateFieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_DateFieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_DateFieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_DateFieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_DateFieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_DateFieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_DateFieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_DateFieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_DateFieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_DateFieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_DateFieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_DateFieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_DateFieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_DateFieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_DateFieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_DateFieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_DateFieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_DateFieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_DateFieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_DateFieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_DateFieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_DateFieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_DateFieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_DateFieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_DateFieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_DateFieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_DateFieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_DateFieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_DateFieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_DateFieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_DateFieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_DateFieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.DateFieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_DateFieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.FieldConfig

Ext.form.FieldConfig = function Ext_form_FieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.FieldConfig.prototype = {
    
    fieldLabel: function Ext_form_FieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_FieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_FieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_FieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_FieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_FieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_FieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_FieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_FieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_FieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_FieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_FieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_FieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_FieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_FieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_FieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_FieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_FieldConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "20", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_FieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_FieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_FieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_FieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_FieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_FieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_FieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_FieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_FieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_FieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_FieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_FieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_FieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_FieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_FieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_FieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_FieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_FieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_FieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_FieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_FieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_FieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_FieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_FieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_FieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_FieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_FieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_FieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_FieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_FieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_FieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_FieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.FieldEvents

Ext.form.FieldEvents = function Ext_form_FieldEvents() {
}
Ext.form.FieldEvents.get_focus = function Ext_form_FieldEvents$get_focus() {
    /// <summary>
    /// Fires when this field receives input focus.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'focus';
}
Ext.form.FieldEvents.get_blur = function Ext_form_FieldEvents$get_blur() {
    /// <summary>
    /// Fires when this field loses input focus.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'blur';
}
Ext.form.FieldEvents.get_specialkey = function Ext_form_FieldEvents$get_specialkey() {
    /// <summary>
    /// Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed.  You can check
    /// {@link Ext.EventObject#getKey} to determine which key was pressed.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'specialkey';
}
Ext.form.FieldEvents.get_change = function Ext_form_FieldEvents$get_change() {
    /// <summary>
    /// Fires just before the field blurs if the field value has changed.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis, {Mixed} newValue, {Mixed} oldValue)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>newValue</b></term><description>The new value</description></item><item><term><b>oldValue</b></term><description>The original value</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'change';
}
Ext.form.FieldEvents.get_invalid = function Ext_form_FieldEvents$get_invalid() {
    /// <summary>
    /// Fires after the field has been marked as invalid.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis, {String} msg)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>msg</b></term><description>The validation message</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'invalid';
}
Ext.form.FieldEvents.get_valid = function Ext_form_FieldEvents$get_valid() {
    /// <summary>
    /// Fires after the field has been validated with no errors.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'valid';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.FieldSetConfig

Ext.form.FieldSetConfig = function Ext_form_FieldSetConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.FieldSetConfig.prototype = {
    
    checkboxToggle: function Ext_form_FieldSetConfig$checkboxToggle(value) {
        /// <summary>
        /// True to render a checkbox into the fieldset frame just in front of the legend, or a DomHelper config object to create the checkbox.  (defaults to false). The fieldset will be expanded or collapsed when the checkbox is toggled.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['checkboxToggle'] = value;
        return this;
    },
    
    checkboxName: function Ext_form_FieldSetConfig$checkboxName(value) {
        /// <summary>
        /// The name to assign to the fieldset's checkbox if {@link #checkboxToggle} = true (defaults to '[checkbox id]-checkbox').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['checkboxName'] = value;
        return this;
    },
    
    labelWidth: function Ext_form_FieldSetConfig$labelWidth(value) {
        /// <summary>
        /// The width of labels. This property cascades to child containers.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['labelWidth'] = value;
        return this;
    },
    
    itemCls: function Ext_form_FieldSetConfig$itemCls(value) {
        /// <summary>
        /// A css class to apply to the x-form-item of fields. This property cascades to child containers.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    baseCls: function Ext_form_FieldSetConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class applied to the fieldset (defaults to 'x-fieldset').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    layout: function Ext_form_FieldSetConfig$layout(value) {
        /// <summary>
        /// The {@link Ext.Container#layout} to use inside the fieldset (defaults to 'form').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    applyTo: function Ext_form_FieldSetConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_form_FieldSetConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_form_FieldSetConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_form_FieldSetConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_form_FieldSetConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_form_FieldSetConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_form_FieldSetConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_form_FieldSetConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_form_FieldSetConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_form_FieldSetConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_form_FieldSetConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_form_FieldSetConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_form_FieldSetConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_form_FieldSetConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_form_FieldSetConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_form_FieldSetConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_form_FieldSetConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_form_FieldSetConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_form_FieldSetConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_form_FieldSetConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_form_FieldSetConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_form_FieldSetConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_form_FieldSetConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_form_FieldSetConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_form_FieldSetConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_form_FieldSetConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_form_FieldSetConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    collapsedCls: function Ext_form_FieldSetConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_form_FieldSetConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_form_FieldSetConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_form_FieldSetConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_form_FieldSetConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_form_FieldSetConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_form_FieldSetConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_form_FieldSetConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_form_FieldSetConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_form_FieldSetConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layoutConfig: function Ext_form_FieldSetConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_form_FieldSetConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_form_FieldSetConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_form_FieldSetConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_form_FieldSetConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_form_FieldSetConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_FieldSetConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_FieldSetConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_FieldSetConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_FieldSetConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_FieldSetConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_FieldSetConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_FieldSetConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_FieldSetConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_FieldSetConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_FieldSetConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_form_FieldSetConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_form_FieldSetConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_FieldSetConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_FieldSetConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_FieldSetConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_form_FieldSetConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_FieldSetConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_FieldSetConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_FieldSetConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_FieldSetConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_FieldSetConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_FieldSetConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_FieldSetConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_FieldSetConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_FieldSetConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FieldSetConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_FieldSetConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.FormPanelConfig

Ext.form.FormPanelConfig = function Ext_form_FormPanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.FormPanelConfig.prototype = {
    
    formId: function Ext_form_FormPanelConfig$formId(value) {
        /// <summary>
        /// (optional) The id of the FORM tag (defaults to an auto-generated id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['formId'] = value;
        return this;
    },
    
    labelWidth: function Ext_form_FormPanelConfig$labelWidth(value) {
        /// <summary>
        /// The width of labels. This property cascades to child containers.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['labelWidth'] = value;
        return this;
    },
    
    itemCls: function Ext_form_FormPanelConfig$itemCls(value) {
        /// <summary>
        /// A css class to apply to the x-form-item of fields. This property cascades to child containers.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    buttonAlign: function Ext_form_FormPanelConfig$buttonAlign(value) {
        /// <summary>
        /// Valid values are "left," "center" and "right" (defaults to "center")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_form_FormPanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width of all buttons in pixels (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    labelAlign: function Ext_form_FormPanelConfig$labelAlign(value) {
        /// <summary>
        /// Valid values are "left," "top" and "right" (defaults to "left"). This property cascades to child containers if not set.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['labelAlign'] = value;
        return this;
    },
    
    monitorValid: function Ext_form_FormPanelConfig$monitorValid(value) {
        /// <summary>
        /// If true the form monitors its valid state <b>client-side</b> and fires a looping event with that state. This is required to bind buttons to the valid state using the config value formBind:true on the button.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['monitorValid'] = value;
        return this;
    },
    
    monitorPoll: function Ext_form_FormPanelConfig$monitorPoll(value) {
        /// <summary>
        /// The milliseconds to poll valid state, ignored if monitorValid is not true (defaults to 200)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['monitorPoll'] = value;
        return this;
    },
    
    applyTo: function Ext_form_FormPanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_form_FormPanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_form_FormPanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_form_FormPanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_form_FormPanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_form_FormPanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_form_FormPanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_form_FormPanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_form_FormPanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_form_FormPanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_form_FormPanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_form_FormPanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_form_FormPanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_form_FormPanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_form_FormPanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_form_FormPanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_form_FormPanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_form_FormPanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_form_FormPanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_form_FormPanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_form_FormPanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_form_FormPanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_form_FormPanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_form_FormPanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_form_FormPanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_form_FormPanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_form_FormPanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_form_FormPanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_form_FormPanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_form_FormPanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_form_FormPanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_form_FormPanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    collapsed: function Ext_form_FormPanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_form_FormPanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    elements: function Ext_form_FormPanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_form_FormPanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_form_FormPanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_form_FormPanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_form_FormPanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_form_FormPanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_form_FormPanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_form_FormPanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_form_FormPanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_FormPanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_FormPanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_FormPanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_FormPanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_FormPanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_FormPanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_FormPanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_FormPanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_FormPanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_FormPanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_form_FormPanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_form_FormPanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_FormPanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_FormPanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_FormPanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_form_FormPanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_FormPanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_FormPanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_FormPanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_FormPanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_FormPanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_FormPanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_FormPanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_FormPanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    reader: function Ext_form_FormPanelConfig$reader(value) {
        /// <param name="value" type="Ext.data.DataReader">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o['reader'] = value;
        return this;
    },
    
    custom: function Ext_form_FormPanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.FormPanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_FormPanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.FormPanelEvents

Ext.form.FormPanelEvents = function Ext_form_FormPanelEvents() {
}
Ext.form.FormPanelEvents.get_clientvalidation = function Ext_form_FormPanelEvents$get_clientvalidation() {
    /// <summary>
    /// If the monitorValid config option is true, this event fires repetitively to notify of valid state
    /// <pre><code>
    /// USAGE: ({Ext.form.FormPanel} objthis, {Boolean} valid)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>valid</b></term><description>true if the form has passed client-side validation</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'clientvalidation';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.HiddenConfig

Ext.form.HiddenConfig = function Ext_form_HiddenConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.HiddenConfig.prototype = {
    
    fieldLabel: function Ext_form_HiddenConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_HiddenConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_HiddenConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_HiddenConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_HiddenConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_HiddenConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_HiddenConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_HiddenConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_HiddenConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_HiddenConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_HiddenConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_HiddenConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_HiddenConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_HiddenConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_HiddenConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_HiddenConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_HiddenConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_HiddenConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "20", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_HiddenConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_HiddenConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_HiddenConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_HiddenConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_HiddenConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_HiddenConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_HiddenConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_HiddenConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_HiddenConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_HiddenConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_HiddenConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_HiddenConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_HiddenConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_HiddenConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_HiddenConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_HiddenConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_HiddenConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_HiddenConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_HiddenConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_HiddenConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_HiddenConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_HiddenConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_HiddenConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_HiddenConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_HiddenConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_HiddenConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_HiddenConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_HiddenConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_HiddenConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_HiddenConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_HiddenConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HiddenConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_HiddenConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.HtmlEditorConfig

Ext.form.HtmlEditorConfig = function Ext_form_HtmlEditorConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.HtmlEditorConfig.prototype = {
    
    enableFormat: function Ext_form_HtmlEditorConfig$enableFormat(value) {
        /// <summary>
        /// Enable the bold, italic and underline buttons (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableFormat'] = value;
        return this;
    },
    
    enableFontSize: function Ext_form_HtmlEditorConfig$enableFontSize(value) {
        /// <summary>
        /// Enable the increase/decrease font size buttons (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableFontSize'] = value;
        return this;
    },
    
    enableColors: function Ext_form_HtmlEditorConfig$enableColors(value) {
        /// <summary>
        /// Enable the fore/highlight color buttons (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableColors'] = value;
        return this;
    },
    
    enableAlignments: function Ext_form_HtmlEditorConfig$enableAlignments(value) {
        /// <summary>
        /// Enable the left, center, right alignment buttons (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableAlignments'] = value;
        return this;
    },
    
    enableLists: function Ext_form_HtmlEditorConfig$enableLists(value) {
        /// <summary>
        /// Enable the bullet and numbered list buttons. Not available in Safari. (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableLists'] = value;
        return this;
    },
    
    enableSourceEdit: function Ext_form_HtmlEditorConfig$enableSourceEdit(value) {
        /// <summary>
        /// Enable the switch to source edit button. Not available in Safari. (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableSourceEdit'] = value;
        return this;
    },
    
    enableLinks: function Ext_form_HtmlEditorConfig$enableLinks(value) {
        /// <summary>
        /// Enable the create link button. Not available in Safari. (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableLinks'] = value;
        return this;
    },
    
    enableFont: function Ext_form_HtmlEditorConfig$enableFont(value) {
        /// <summary>
        /// Enable font selection. Not available in Safari. (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['enableFont'] = value;
        return this;
    },
    
    createLinkText: function Ext_form_HtmlEditorConfig$createLinkText(value) {
        /// <summary>
        /// The default text for the create link prompt
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['createLinkText'] = value;
        return this;
    },
    
    defaultLinkValue: function Ext_form_HtmlEditorConfig$defaultLinkValue(value) {
        /// <summary>
        /// The default value for the create link prompt (defaults to http:/ /)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['defaultLinkValue'] = value;
        return this;
    },
    
    fontFamilies: function Ext_form_HtmlEditorConfig$fontFamilies(value) {
        /// <summary>
        /// An array of available font families
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['fontFamilies'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_HtmlEditorConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_HtmlEditorConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_HtmlEditorConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_HtmlEditorConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_HtmlEditorConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_HtmlEditorConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_HtmlEditorConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_HtmlEditorConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_HtmlEditorConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_HtmlEditorConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_HtmlEditorConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_HtmlEditorConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_HtmlEditorConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_HtmlEditorConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_HtmlEditorConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_HtmlEditorConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_HtmlEditorConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_HtmlEditorConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "20", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_HtmlEditorConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_HtmlEditorConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_HtmlEditorConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_HtmlEditorConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_HtmlEditorConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_HtmlEditorConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_HtmlEditorConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_HtmlEditorConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_HtmlEditorConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_HtmlEditorConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_HtmlEditorConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_HtmlEditorConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_HtmlEditorConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_HtmlEditorConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_HtmlEditorConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_HtmlEditorConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_HtmlEditorConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_HtmlEditorConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_HtmlEditorConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_HtmlEditorConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_HtmlEditorConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_HtmlEditorConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_HtmlEditorConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_HtmlEditorConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_HtmlEditorConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_HtmlEditorConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_HtmlEditorConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_HtmlEditorConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_HtmlEditorConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_HtmlEditorConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_HtmlEditorConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.HtmlEditorConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_HtmlEditorConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.HtmlEditorEvents

Ext.form.HtmlEditorEvents = function Ext_form_HtmlEditorEvents() {
}
Ext.form.HtmlEditorEvents.get_initialize = function Ext_form_HtmlEditorEvents$get_initialize() {
    /// <summary>
    /// Fires when the editor is fully initialized (including the iframe)
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'initialize';
}
Ext.form.HtmlEditorEvents.get_activate = function Ext_form_HtmlEditorEvents$get_activate() {
    /// <summary>
    /// Fires when the editor is first receives the focus. Any insertion must wait
    /// until after this event.
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'activate';
}
Ext.form.HtmlEditorEvents.get_beforesync = function Ext_form_HtmlEditorEvents$get_beforesync() {
    /// <summary>
    /// Fires before the textarea is updated with content from the editor iframe. Return false
    /// to cancel the sync.
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis, {String} html)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>html</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforesync';
}
Ext.form.HtmlEditorEvents.get_beforepush = function Ext_form_HtmlEditorEvents$get_beforepush() {
    /// <summary>
    /// Fires before the iframe editor is updated with content from the textarea. Return false
    /// to cancel the push.
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis, {String} html)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>html</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforepush';
}
Ext.form.HtmlEditorEvents.get_sync = function Ext_form_HtmlEditorEvents$get_sync() {
    /// <summary>
    /// Fires when the textarea is updated with content from the editor iframe.
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis, {String} html)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>html</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'sync';
}
Ext.form.HtmlEditorEvents.get_push = function Ext_form_HtmlEditorEvents$get_push() {
    /// <summary>
    /// Fires when the iframe editor is updated with content from the textarea.
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis, {String} html)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>html</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'push';
}
Ext.form.HtmlEditorEvents.get_editmodechange = function Ext_form_HtmlEditorEvents$get_editmodechange() {
    /// <summary>
    /// Fires when the editor switches edit modes
    /// <pre><code>
    /// USAGE: ({HtmlEditor} objthis, {Boolean} sourceEdit)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>sourceEdit</b></term><description>True if source edit, false if standard editing.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'editmodechange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.LabelConfig

Ext.form.LabelConfig = function Ext_form_LabelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.LabelConfig.prototype = {
    
    text: function Ext_form_LabelConfig$text(value) {
        /// <summary>
        /// The text to display within the label
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    forId: function Ext_form_LabelConfig$forId(value) {
        /// <summary>
        /// The id of the element to which this label will be bound
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['forId'] = value;
        return this;
    },
    
    x: function Ext_form_LabelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_LabelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_LabelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_LabelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_LabelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_LabelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_LabelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_LabelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_LabelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_LabelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_LabelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_form_LabelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_form_LabelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_LabelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_LabelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_LabelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_LabelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_LabelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_LabelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_LabelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_LabelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_LabelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_LabelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_LabelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_LabelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_LabelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_LabelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.LabelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_LabelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.NumberFieldConfig

Ext.form.NumberFieldConfig = function Ext_form_NumberFieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.NumberFieldConfig.prototype = {
    
    fieldClass: function Ext_form_NumberFieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field x-form-num-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    allowDecimals: function Ext_form_NumberFieldConfig$allowDecimals(value) {
        /// <summary>
        /// False to disallow decimal values (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['allowDecimals'] = value;
        return this;
    },
    
    decimalSeparator: function Ext_form_NumberFieldConfig$decimalSeparator(value) {
        /// <summary>
        /// Character(s) to allow as the decimal separator (defaults to '.')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['decimalSeparator'] = value;
        return this;
    },
    
    decimalPrecision: function Ext_form_NumberFieldConfig$decimalPrecision(value) {
        /// <summary>
        /// The maximum precision to display after the decimal separator (defaults to 2)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['decimalPrecision'] = value;
        return this;
    },
    
    allowNegative: function Ext_form_NumberFieldConfig$allowNegative(value) {
        /// <summary>
        /// False to prevent entering a negative sign (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['allowNegative'] = value;
        return this;
    },
    
    minValue: function Ext_form_NumberFieldConfig$minValue(value) {
        /// <summary>
        /// The minimum allowed value (defaults to Number.NEGATIVE_INFINITY)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['minValue'] = value;
        return this;
    },
    
    maxValue: function Ext_form_NumberFieldConfig$maxValue(value) {
        /// <summary>
        /// The maximum allowed value (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['maxValue'] = value;
        return this;
    },
    
    minText: function Ext_form_NumberFieldConfig$minText(value) {
        /// <summary>
        /// Error text to display if the minimum value validation fails (defaults to "The minimum value for this field is {minValue}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['minText'] = value;
        return this;
    },
    
    maxText: function Ext_form_NumberFieldConfig$maxText(value) {
        /// <summary>
        /// Error text to display if the maximum value validation fails (defaults to "The maximum value for this field is {maxValue}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['maxText'] = value;
        return this;
    },
    
    nanText: function Ext_form_NumberFieldConfig$nanText(value) {
        /// <summary>
        /// Error text to display if the value is not a valid number.  For example, this can happen if a valid character like '.' or '-' is left in the field with no number (defaults to "{value} is not a valid number")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['nanText'] = value;
        return this;
    },
    
    baseChars: function Ext_form_NumberFieldConfig$baseChars(value) {
        /// <summary>
        /// The base set of characters to evaluate as valid numbers (defaults to '0123456789').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['baseChars'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_NumberFieldConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_NumberFieldConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_NumberFieldConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_NumberFieldConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_NumberFieldConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_NumberFieldConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_NumberFieldConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_NumberFieldConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_NumberFieldConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_NumberFieldConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_NumberFieldConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_NumberFieldConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_NumberFieldConfig$selectOnFocus(value) {
        /// <summary>
        /// True to automatically select any existing field text when the field receives input focus (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    blankText: function Ext_form_NumberFieldConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_NumberFieldConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_NumberFieldConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_NumberFieldConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_NumberFieldConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_NumberFieldConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_NumberFieldConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_NumberFieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_NumberFieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_NumberFieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_NumberFieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_NumberFieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_NumberFieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_NumberFieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_NumberFieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_NumberFieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_NumberFieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_NumberFieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_NumberFieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_NumberFieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_NumberFieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_NumberFieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_NumberFieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_NumberFieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_NumberFieldConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "20", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_NumberFieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_NumberFieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_NumberFieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_NumberFieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_NumberFieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_NumberFieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_NumberFieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_NumberFieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_NumberFieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_NumberFieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_NumberFieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_NumberFieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_NumberFieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_NumberFieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_NumberFieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_NumberFieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_NumberFieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_NumberFieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_NumberFieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_NumberFieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_NumberFieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_NumberFieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_NumberFieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_NumberFieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_NumberFieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_NumberFieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_NumberFieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_NumberFieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_NumberFieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_NumberFieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.NumberFieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_NumberFieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.RadioConfig

Ext.form.RadioConfig = function Ext_form_RadioConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.RadioConfig.prototype = {
    
    focusClass: function Ext_form_RadioConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the checkbox receives focus (defaults to undefined)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_RadioConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the checkbox (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    checked_: function Ext_form_RadioConfig$checked_(value) {
        /// <summary>
        /// True if the the checkbox should render already checked (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['checked'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_RadioConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "checkbox", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    boxLabel: function Ext_form_RadioConfig$boxLabel(value) {
        /// <summary>
        /// The text that appears beside the checkbox
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['boxLabel'] = value;
        return this;
    },
    
    inputValue: function Ext_form_RadioConfig$inputValue(value) {
        /// <summary>
        /// The value that should go into the generated input element's value attribute
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['inputValue'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_RadioConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_RadioConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_RadioConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_RadioConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_RadioConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_RadioConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_RadioConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_RadioConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_RadioConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_RadioConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_RadioConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_RadioConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_RadioConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_RadioConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_RadioConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_RadioConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_RadioConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_RadioConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_RadioConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_RadioConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_RadioConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_RadioConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_RadioConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_RadioConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_RadioConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_RadioConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_RadioConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_RadioConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_RadioConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_RadioConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_RadioConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_RadioConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_RadioConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_RadioConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_RadioConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_RadioConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_RadioConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_RadioConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_RadioConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_RadioConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_RadioConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_RadioConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_RadioConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_RadioConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_RadioConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_RadioConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.RadioConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_RadioConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.TextAreaConfig

Ext.form.TextAreaConfig = function Ext_form_TextAreaConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.TextAreaConfig.prototype = {
    
    growMin: function Ext_form_TextAreaConfig$growMin(value) {
        /// <summary>
        /// The minimum height to allow when grow = true (defaults to 60)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_TextAreaConfig$growMax(value) {
        /// <summary>
        /// The maximum height to allow when grow = true (defaults to 1000)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    preventScrollbars: function Ext_form_TextAreaConfig$preventScrollbars(value) {
        /// <summary>
        /// True to prevent scrollbars from appearing regardless of how much text is in the field (equivalent to setting overflow: hidden, defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['preventScrollbars'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_TextAreaConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "textarea", style: "width:100px;height:60px;", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_TextAreaConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_TextAreaConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    vtype: function Ext_form_TextAreaConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_TextAreaConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_TextAreaConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_TextAreaConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_TextAreaConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_TextAreaConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_TextAreaConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_TextAreaConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_TextAreaConfig$selectOnFocus(value) {
        /// <summary>
        /// True to automatically select any existing field text when the field receives input focus (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    blankText: function Ext_form_TextAreaConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_TextAreaConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_TextAreaConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_TextAreaConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_TextAreaConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_TextAreaConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_TextAreaConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_TextAreaConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_TextAreaConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_TextAreaConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_TextAreaConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_TextAreaConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_TextAreaConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_TextAreaConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_TextAreaConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_TextAreaConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_TextAreaConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_TextAreaConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_TextAreaConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_TextAreaConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_TextAreaConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_TextAreaConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_TextAreaConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_TextAreaConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_TextAreaConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_TextAreaConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_TextAreaConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_TextAreaConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_TextAreaConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_TextAreaConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_TextAreaConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_TextAreaConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_TextAreaConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_TextAreaConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_TextAreaConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_TextAreaConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_TextAreaConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_TextAreaConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_TextAreaConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_TextAreaConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_TextAreaConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_TextAreaConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_TextAreaConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_TextAreaConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_TextAreaConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_TextAreaConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_TextAreaConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_TextAreaConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_TextAreaConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_TextAreaConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_TextAreaConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_TextAreaConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_TextAreaConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_TextAreaConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_TextAreaConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextAreaConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_TextAreaConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.TextFieldConfig

Ext.form.TextFieldConfig = function Ext_form_TextFieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.TextFieldConfig.prototype = {
    
    vtypeText: function Ext_form_TextFieldConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_TextFieldConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_TextFieldConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_TextFieldConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_TextFieldConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_TextFieldConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_TextFieldConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_TextFieldConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_TextFieldConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_TextFieldConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_TextFieldConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_TextFieldConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_TextFieldConfig$selectOnFocus(value) {
        /// <summary>
        /// True to automatically select any existing field text when the field receives input focus (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    blankText: function Ext_form_TextFieldConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_TextFieldConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_TextFieldConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_TextFieldConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_TextFieldConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_TextFieldConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_TextFieldConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_TextFieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_TextFieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_TextFieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_TextFieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_TextFieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_TextFieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_TextFieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_TextFieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_TextFieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_TextFieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_TextFieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_TextFieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_TextFieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_TextFieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_TextFieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_TextFieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_TextFieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_TextFieldConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "20", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_TextFieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_TextFieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_TextFieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_TextFieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_TextFieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_TextFieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_TextFieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_TextFieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_TextFieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_TextFieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_TextFieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_TextFieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_TextFieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_TextFieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_TextFieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_TextFieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_TextFieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_TextFieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_TextFieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_TextFieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_TextFieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_TextFieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_TextFieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_TextFieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_TextFieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_TextFieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_TextFieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_TextFieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_TextFieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_TextFieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_TextFieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TextFieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_TextFieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.TextFieldEvents

Ext.form.TextFieldEvents = function Ext_form_TextFieldEvents() {
}
Ext.form.TextFieldEvents.get_autosize = function Ext_form_TextFieldEvents$get_autosize() {
    /// <summary>
    /// Fires when the autosize function is triggered.  The field may or may not have actually changed size
    /// according to the default logic, but this event provides a hook for the developer to apply additional
    /// logic at runtime to resize the field if needed.
    /// <pre><code>
    /// USAGE: ({Ext.form.Field} objthis, {Number} width)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This text field</description></item><item><term><b>width</b></term><description>The new field width</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'autosize';
}
Ext.form.TextFieldEvents.get_keydown = function Ext_form_TextFieldEvents$get_keydown() {
    /// <summary>
    /// Keydown input field event. This event only fires if enableKeyEvents is set to true.
    /// <pre><code>
    /// USAGE: ({Ext.form.TextField} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This text field</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'keydown';
}
Ext.form.TextFieldEvents.get_keyup = function Ext_form_TextFieldEvents$get_keyup() {
    /// <summary>
    /// Keyup input field event. This event only fires if enableKeyEvents is set to true.
    /// <pre><code>
    /// USAGE: ({Ext.form.TextField} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This text field</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'keyup';
}
Ext.form.TextFieldEvents.get_keypress = function Ext_form_TextFieldEvents$get_keypress() {
    /// <summary>
    /// Keypress input field event. This event only fires if enableKeyEvents is set to true.
    /// <pre><code>
    /// USAGE: ({Ext.form.TextField} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This text field</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'keypress';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.TimeFieldConfig

Ext.form.TimeFieldConfig = function Ext_form_TimeFieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.TimeFieldConfig.prototype = {
    
    minValue: function Ext_form_TimeFieldConfig$minValue(value) {
        /// <summary>
        /// {Date/String}  The minimum allowed time. Can be either a Javascript date object or a string date in a valid format (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minValue'] = value;
        return this;
    },
    
    maxValue: function Ext_form_TimeFieldConfig$maxValue(value) {
        /// <summary>
        /// {Date/String}  The maximum allowed time. Can be either a Javascript date object or a string date in a valid format (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maxValue'] = value;
        return this;
    },
    
    minText: function Ext_form_TimeFieldConfig$minText(value) {
        /// <summary>
        /// The error text to display when the date in the cell is before minValue (defaults to 'The time in this field must be equal to or after {0}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minText'] = value;
        return this;
    },
    
    maxText: function Ext_form_TimeFieldConfig$maxText(value) {
        /// <summary>
        /// The error text to display when the time is after maxValue (defaults to 'The time in this field must be equal to or before {0}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maxText'] = value;
        return this;
    },
    
    invalidText: function Ext_form_TimeFieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to display when the time in the field is invalid (defaults to '{value} is not a valid time - it must be in the format {format}').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    format: function Ext_form_TimeFieldConfig$format(value) {
        /// <summary>
        /// The default date format string which can be overriden for localization support.  The format must be valid according to {@link Date#parseDate} (defaults to 'm/d/y').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['format'] = value;
        return this;
    },
    
    altFormats: function Ext_form_TimeFieldConfig$altFormats(value) {
        /// <summary>
        /// Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined format (defaults to 'm/d/Y|m-d-y|m-d-Y|m/d|m-d|d').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['altFormats'] = value;
        return this;
    },
    
    increment: function Ext_form_TimeFieldConfig$increment(value) {
        /// <summary>
        /// The number of minutes between each time value in the list (defaults to 15).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['increment'] = value;
        return this;
    },
    
    transform: function Ext_form_TimeFieldConfig$transform(value) {
        /// <summary>
        /// The id, DOM node or element of an existing HTML SELECT to convert to a ComboBox. Note that if you specify this and the combo is going to be in a {@link Ext.form.BasicForm} or {@link Ext.form.FormPanel}, you must also set {@link #lazyRender} = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['transform'] = value;
        return this;
    },
    
    lazyRender: function Ext_form_TimeFieldConfig$lazyRender(value) {
        /// <summary>
        /// True to prevent the ComboBox from rendering until requested (should always be used when rendering into an Ext.Editor, defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['lazyRender'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_TimeFieldConfig$autoCreate(value) {
        /// <summary>
        /// {Boolean/Object} A DomHelper element spec, or true for a default element spec (defaults to: {tag: "input", type: "text", size: "24", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    store: function Ext_form_TimeFieldConfig$store(value) {
        /// <summary>
        /// {Ext.data.Store/Array} The data source to which this combo is bound (defaults to undefined).  This can be any {@link Ext.data.Store} subclass, a 1-dimensional array (e.g., ['Foo','Bar']) or a 2-dimensional array (e.g., [['f','Foo'],['b','Bar']]).  Arrays will be converted to a {@link Ext.data.SimpleStore} internally. 1-dimensional arrays will automatically be expanded (each array item will be the combo value and text) and for multi-dimensional arrays, the value in index 0 of each item will be assumed to be the combo value, while the value at index 1 is assumed to be the combo text.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    title: function Ext_form_TimeFieldConfig$title(value) {
        /// <summary>
        /// If supplied, a header element is created containing this text and added into the top of the dropdown list (defaults to undefined, with no header element)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    listWidth: function Ext_form_TimeFieldConfig$listWidth(value) {
        /// <summary>
        /// The width in pixels of the dropdown list (defaults to the width of the ComboBox field)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['listWidth'] = value;
        return this;
    },
    
    displayField: function Ext_form_TimeFieldConfig$displayField(value) {
        /// <summary>
        /// The underlying data field name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'text' if transforming a select)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['displayField'] = value;
        return this;
    },
    
    valueField: function Ext_form_TimeFieldConfig$valueField(value) {
        /// <summary>
        /// The underlying data value name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'value' if transforming a select) Note: use of a valueField requires the user to make a selection in order for a value to be mapped.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['valueField'] = value;
        return this;
    },
    
    hiddenName: function Ext_form_TimeFieldConfig$hiddenName(value) {
        /// <summary>
        /// If specified, a hidden form field with this name is dynamically generated to store the field's data value (defaults to the underlying DOM element's name). Required for the combo's value to automatically post during a form submission.  Note that the hidden field's id will also default to this name if {@link #hiddenId} is not specified.  The combo's id and the hidden field's ids should be different, since no two DOM nodes should share the same id, so if the combo and hidden names are the same, you should specify a unique hiddenId.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hiddenName'] = value;
        return this;
    },
    
    hiddenId: function Ext_form_TimeFieldConfig$hiddenId(value) {
        /// <summary>
        /// If {@link #hiddenName} is specified, hiddenId can also be provided to give the hidden field a unique id (defaults to the hiddenName).  The hiddenId and combo {@link #id} should be different, since no two DOM nodes should share the same id.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hiddenId'] = value;
        return this;
    },
    
    listClass: function Ext_form_TimeFieldConfig$listClass(value) {
        /// <summary>
        /// CSS class to apply to the dropdown list element (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['listClass'] = value;
        return this;
    },
    
    selectedClass: function Ext_form_TimeFieldConfig$selectedClass(value) {
        /// <summary>
        /// CSS class to apply to the selected item in the dropdown list (defaults to 'x-combo-selected')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['selectedClass'] = value;
        return this;
    },
    
    triggerClass: function Ext_form_TimeFieldConfig$triggerClass(value) {
        /// <summary>
        /// An additional CSS class used to style the trigger button.  The trigger will always get the class 'x-form-trigger' and triggerClass will be <b>appended</b> if specified (defaults to 'x-form-arrow-trigger' which displays a downward arrow icon).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['triggerClass'] = value;
        return this;
    },
    
    shadow: function Ext_form_TimeFieldConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    listAlign: function Ext_form_TimeFieldConfig$listAlign(value) {
        /// <summary>
        /// A valid anchor position value. See {@link Ext.Element#alignTo} for details on supported anchor positions (defaults to 'tl-bl')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['listAlign'] = value;
        return this;
    },
    
    maxHeight: function Ext_form_TimeFieldConfig$maxHeight(value) {
        /// <summary>
        /// The maximum height in pixels of the dropdown list before scrollbars are shown (defaults to 300)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    minHeight: function Ext_form_TimeFieldConfig$minHeight(value) {
        /// <summary>
        /// The minimum height in pixels of the dropdown list when the list is constrained by its distance to the viewport edges (defaults to 90)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    triggerAction: function Ext_form_TimeFieldConfig$triggerAction(value) {
        /// <summary>
        /// The action to execute when the trigger field is activated.  Use 'all' to run the query specified by the allQuery config option (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['triggerAction'] = value;
        return this;
    },
    
    minChars: function Ext_form_TimeFieldConfig$minChars(value) {
        /// <summary>
        /// The minimum number of characters the user must type before autocomplete and typeahead activate (defaults to 4 if remote or 0 if local, does not apply if editable = false)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minChars'] = value;
        return this;
    },
    
    typeAhead: function Ext_form_TimeFieldConfig$typeAhead(value) {
        /// <summary>
        /// True to populate and autoselect the remainder of the text being typed after a configurable delay ({@link #typeAheadDelay}) if it matches a known value (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['typeAhead'] = value;
        return this;
    },
    
    queryDelay: function Ext_form_TimeFieldConfig$queryDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown list (defaults to 500 if mode = 'remote' or 10 if mode = 'local')
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['queryDelay'] = value;
        return this;
    },
    
    pageSize: function Ext_form_TimeFieldConfig$pageSize(value) {
        /// <summary>
        /// If greater than 0, a paging toolbar is displayed in the footer of the dropdown list and the filter queries will execute with page start and limit parameters.  Only applies when mode = 'remote' (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['pageSize'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_TimeFieldConfig$selectOnFocus(value) {
        /// <summary>
        /// True to select any existing text in the field immediately on focus.  Only applies when editable = true (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    queryParam: function Ext_form_TimeFieldConfig$queryParam(value) {
        /// <summary>
        /// Name of the query as it will be passed on the querystring (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['queryParam'] = value;
        return this;
    },
    
    loadingText: function Ext_form_TimeFieldConfig$loadingText(value) {
        /// <summary>
        /// The text to display in the dropdown list while data is loading.  Only applies when mode = 'remote' (defaults to 'Loading...')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['loadingText'] = value;
        return this;
    },
    
    resizable: function Ext_form_TimeFieldConfig$resizable(value) {
        /// <summary>
        /// True to add a resize handle to the bottom of the dropdown list (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    handleHeight: function Ext_form_TimeFieldConfig$handleHeight(value) {
        /// <summary>
        /// The height in pixels of the dropdown list resize handle if resizable = true (defaults to 8)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['handleHeight'] = value;
        return this;
    },
    
    editable: function Ext_form_TimeFieldConfig$editable(value) {
        /// <summary>
        /// False to prevent the user from typing text directly into the field, just like a traditional select (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['editable'] = value;
        return this;
    },
    
    allQuery: function Ext_form_TimeFieldConfig$allQuery(value) {
        /// <summary>
        /// The text query to send to the server to return all records for the list with no filtering (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['allQuery'] = value;
        return this;
    },
    
    mode: function Ext_form_TimeFieldConfig$mode(value) {
        /// <summary>
        /// Set to 'local' if the ComboBox loads local data (defaults to 'remote' which loads from the server)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['mode'] = value;
        return this;
    },
    
    minListWidth: function Ext_form_TimeFieldConfig$minListWidth(value) {
        /// <summary>
        /// The minimum width of the dropdown list in pixels (defaults to 70, will be ignored if listWidth has a higher value)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minListWidth'] = value;
        return this;
    },
    
    forceSelection: function Ext_form_TimeFieldConfig$forceSelection(value) {
        /// <summary>
        /// True to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text into the field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['forceSelection'] = value;
        return this;
    },
    
    typeAheadDelay: function Ext_form_TimeFieldConfig$typeAheadDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['typeAheadDelay'] = value;
        return this;
    },
    
    valueNotFoundText: function Ext_form_TimeFieldConfig$valueNotFoundText(value) {
        /// <summary>
        /// When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be displayed as the field text if defined (defaults to undefined). If this defaut text is used, it means there is no value set and no validation will occur on this field.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['valueNotFoundText'] = value;
        return this;
    },
    
    lazyInit: function Ext_form_TimeFieldConfig$lazyInit(value) {
        /// <summary>
        /// True to not initialize the list for this combo until the field is focused (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['lazyInit'] = value;
        return this;
    },
    
    tpl: function Ext_form_TimeFieldConfig$tpl(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['tpl'] = value;
        return this;
    },
    
    itemSelector: function Ext_form_TimeFieldConfig$itemSelector(value) {
        /// <summary>
        /// <b>This setting is required if a custom XTemplate has been specified in {@link #tpl} which assigns a class other than <pre>'x-combo-list-item'</pre> to dropdown list items</b>. A simple CSS selector (e.g. div.some-class or span:first-child) that will be used to determine what nodes the DataView which handles the dropdown display will be working with.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['itemSelector'] = value;
        return this;
    },
    
    hideTrigger: function Ext_form_TimeFieldConfig$hideTrigger(value) {
        /// <summary>
        /// True to hide the trigger element and display only the base text field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hideTrigger'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_TimeFieldConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_TimeFieldConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_TimeFieldConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_TimeFieldConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_TimeFieldConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_TimeFieldConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_TimeFieldConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_TimeFieldConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_TimeFieldConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_TimeFieldConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_TimeFieldConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_TimeFieldConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    blankText: function Ext_form_TimeFieldConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_TimeFieldConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_TimeFieldConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_TimeFieldConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_TimeFieldConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_TimeFieldConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_TimeFieldConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_TimeFieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_TimeFieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_TimeFieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_TimeFieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_TimeFieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_TimeFieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_TimeFieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_TimeFieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_TimeFieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_TimeFieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_TimeFieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_TimeFieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    focusClass: function Ext_form_TimeFieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_TimeFieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_TimeFieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_TimeFieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_TimeFieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_TimeFieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_TimeFieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_TimeFieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_TimeFieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_TimeFieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_TimeFieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_TimeFieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_TimeFieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_TimeFieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_TimeFieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_TimeFieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_TimeFieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_TimeFieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_TimeFieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_TimeFieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_TimeFieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_TimeFieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_TimeFieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_TimeFieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_TimeFieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_TimeFieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_TimeFieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_TimeFieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_TimeFieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_TimeFieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_TimeFieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_TimeFieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_TimeFieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_TimeFieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_TimeFieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TimeFieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_TimeFieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.TriggerFieldConfig

Ext.form.TriggerFieldConfig = function Ext_form_TriggerFieldConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.TriggerFieldConfig.prototype = {
    
    triggerClass: function Ext_form_TriggerFieldConfig$triggerClass(value) {
        /// <summary>
        /// An additional CSS class used to style the trigger button.  The trigger will always get the
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['triggerClass'] = value;
        return this;
    },
    
    autoCreate: function Ext_form_TriggerFieldConfig$autoCreate(value) {
        /// <summary>
        /// {String/Object} A DomHelper element spec, or true for a default element spec (defaults to {tag: "input", type: "text", size: "16", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    hideTrigger: function Ext_form_TriggerFieldConfig$hideTrigger(value) {
        /// <summary>
        /// True to hide the trigger element and display only the base text field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['hideTrigger'] = value;
        return this;
    },
    
    vtypeText: function Ext_form_TriggerFieldConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_form_TriggerFieldConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_form_TriggerFieldConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_form_TriggerFieldConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_form_TriggerFieldConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_form_TriggerFieldConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_form_TriggerFieldConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_form_TriggerFieldConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    minLength: function Ext_form_TriggerFieldConfig$minLength(value) {
        /// <summary>
        /// Minimum input field length required (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    maxLength: function Ext_form_TriggerFieldConfig$maxLength(value) {
        /// <summary>
        /// Maximum input field length allowed (defaults to Number.MAX_VALUE)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_form_TriggerFieldConfig$minLengthText(value) {
        /// <summary>
        /// Error text to display if the minimum length validation fails (defaults to "The minimum length for this field is {minLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLengthText: function Ext_form_TriggerFieldConfig$maxLengthText(value) {
        /// <summary>
        /// Error text to display if the maximum length validation fails (defaults to "The maximum length for this field is {maxLength}")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_form_TriggerFieldConfig$selectOnFocus(value) {
        /// <summary>
        /// True to automatically select any existing field text when the field receives input focus (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    blankText: function Ext_form_TriggerFieldConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_form_TriggerFieldConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_form_TriggerFieldConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_form_TriggerFieldConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_form_TriggerFieldConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_form_TriggerFieldConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_form_TriggerFieldConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_form_TriggerFieldConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_form_TriggerFieldConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_form_TriggerFieldConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_form_TriggerFieldConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_form_TriggerFieldConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_form_TriggerFieldConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_form_TriggerFieldConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_form_TriggerFieldConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_form_TriggerFieldConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_form_TriggerFieldConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_form_TriggerFieldConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_form_TriggerFieldConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_form_TriggerFieldConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_form_TriggerFieldConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_form_TriggerFieldConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_form_TriggerFieldConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_form_TriggerFieldConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_form_TriggerFieldConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_form_TriggerFieldConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_form_TriggerFieldConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_form_TriggerFieldConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_form_TriggerFieldConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_form_TriggerFieldConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_form_TriggerFieldConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_form_TriggerFieldConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_form_TriggerFieldConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_form_TriggerFieldConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_form_TriggerFieldConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_form_TriggerFieldConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_form_TriggerFieldConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_form_TriggerFieldConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_form_TriggerFieldConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_form_TriggerFieldConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_form_TriggerFieldConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_form_TriggerFieldConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_form_TriggerFieldConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_form_TriggerFieldConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_form_TriggerFieldConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_form_TriggerFieldConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_form_TriggerFieldConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_form_TriggerFieldConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_form_TriggerFieldConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_form_TriggerFieldConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_form_TriggerFieldConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_form_TriggerFieldConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_form_TriggerFieldConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_form_TriggerFieldConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_form_TriggerFieldConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.TriggerFieldConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_TriggerFieldConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.VTypesConfig

Ext.form.VTypesConfig = function Ext_form_VTypesConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.VTypesConfig.prototype = {
    
    custom: function Ext_form_VTypesConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.VTypesConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_VTypesConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.form.Action');

////////////////////////////////////////////////////////////////////////////////
// Ext.form.Action.LoadConfig

Ext.form.Action.LoadConfig = function Ext_form_Action_LoadConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.Action.LoadConfig.prototype = {
    
    url: function Ext_form_Action_LoadConfig$url(value) {
        /// <summary>
        /// The URL that the Action is to invoke.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    method: function Ext_form_Action_LoadConfig$method(value) {
        /// <summary>
        /// The HTTP method to use to access the requested URL. Defaults to the {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    params_: function Ext_form_Action_LoadConfig$params_(value) {
        /// <summary>
        /// Extra parameter values to pass. These are added to the Form's {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's input fields.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['params'] = value;
        return this;
    },
    
    timeout: function Ext_form_Action_LoadConfig$timeout(value) {
        /// <summary>
        /// The number of milliseconds to wait for a server response before failing with the {@link #failureType} as {@link #CONNECT_FAILURE}.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    success: function Ext_form_Action_LoadConfig$success(value) {
        /// <summary>
        /// The function to call when a valid success return packet is recieved. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['success'] = value;
        return this;
    },
    
    failure: function Ext_form_Action_LoadConfig$failure(value) {
        /// <summary>
        /// The function to call when a failure packet was recieved, or when an error ocurred in the Ajax communication. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. If an Ajax error ocurred, the failure type will be in {@link #failureType}. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['failure'] = value;
        return this;
    },
    
    scope: function Ext_form_Action_LoadConfig$scope(value) {
        /// <summary>
        /// The scope in which to call the callback functions (The <tt>this</tt> reference for the callback functions).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    waitMsg: function Ext_form_Action_LoadConfig$waitMsg(value) {
        /// <summary>
        /// The message to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['waitMsg'] = value;
        return this;
    },
    
    waitTitle: function Ext_form_Action_LoadConfig$waitTitle(value) {
        /// <summary>
        /// The title to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o['waitTitle'] = value;
        return this;
    },
    
    custom: function Ext_form_Action_LoadConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.LoadConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_Action_LoadConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.form.Action.SubmitConfig

Ext.form.Action.SubmitConfig = function Ext_form_Action_SubmitConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.form.Action.SubmitConfig.prototype = {
    
    clientValidation: function Ext_form_Action_SubmitConfig$clientValidation(value) {
        /// <summary>
        /// Determines whether a Form's fields are validated in a final call to {@link Ext.form.BasicForm#isValid isValid} prior to submission. Pass <tt>false</tt> in the Form's submit options to prevent this. If not defined, pre-submission field validation is performed.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['clientValidation'] = value;
        return this;
    },
    
    url: function Ext_form_Action_SubmitConfig$url(value) {
        /// <summary>
        /// The URL that the Action is to invoke.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    method: function Ext_form_Action_SubmitConfig$method(value) {
        /// <summary>
        /// The HTTP method to use to access the requested URL. Defaults to the {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['method'] = value;
        return this;
    },
    
    params_: function Ext_form_Action_SubmitConfig$params_(value) {
        /// <summary>
        /// Extra parameter values to pass. These are added to the Form's {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's input fields.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['params'] = value;
        return this;
    },
    
    timeout: function Ext_form_Action_SubmitConfig$timeout(value) {
        /// <summary>
        /// The number of milliseconds to wait for a server response before failing with the {@link #failureType} as {@link #CONNECT_FAILURE}.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['timeout'] = value;
        return this;
    },
    
    success: function Ext_form_Action_SubmitConfig$success(value) {
        /// <summary>
        /// The function to call when a valid success return packet is recieved. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['success'] = value;
        return this;
    },
    
    failure: function Ext_form_Action_SubmitConfig$failure(value) {
        /// <summary>
        /// The function to call when a failure packet was recieved, or when an error ocurred in the Ajax communication. The function is passed the following parameters:<ul class="mdetail-params"><li><b>form</b> : Ext.form.BasicForm<div class="sub-desc">The form that requested the action</div></li><li><b>action</b> : Ext.form.Action<div class="sub-desc">The Action class. If an Ajax error ocurred, the failure type will be in {@link #failureType}. The {@link #result} property of this object may be examined to perform custom postprocessing.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['failure'] = value;
        return this;
    },
    
    scope: function Ext_form_Action_SubmitConfig$scope(value) {
        /// <summary>
        /// The scope in which to call the callback functions (The <tt>this</tt> reference for the callback functions).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    waitMsg: function Ext_form_Action_SubmitConfig$waitMsg(value) {
        /// <summary>
        /// The message to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['waitMsg'] = value;
        return this;
    },
    
    waitTitle: function Ext_form_Action_SubmitConfig$waitTitle(value) {
        /// <summary>
        /// The title to be displayed by a call to {@link Ext.MessageBox#wait} during the time the action is being processed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o['waitTitle'] = value;
        return this;
    },
    
    custom: function Ext_form_Action_SubmitConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.form.Action.SubmitConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_form_Action_SubmitConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.grid');

////////////////////////////////////////////////////////////////////////////////
// Ext.grid.AbstractSelectionModelConfig

Ext.grid.AbstractSelectionModelConfig = function Ext_grid_AbstractSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.AbstractSelectionModelConfig.prototype = {
    
    listeners: function Ext_grid_AbstractSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.AbstractSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_AbstractSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.AbstractSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_AbstractSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.CellSelectionModelConfig

Ext.grid.CellSelectionModelConfig = function Ext_grid_CellSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.CellSelectionModelConfig.prototype = {
    
    listeners: function Ext_grid_CellSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.CellSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_CellSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.CellSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_CellSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.CellSelectionModelEvents

Ext.grid.CellSelectionModelEvents = function Ext_grid_CellSelectionModelEvents() {
}
Ext.grid.CellSelectionModelEvents.get_beforecellselect = function Ext_grid_CellSelectionModelEvents$get_beforecellselect() {
    /// <summary>
    /// Fires before a cell is selected.
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis, {Number} rowIndex, {Number} colIndex)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The selected row index</description></item><item><term><b>colIndex</b></term><description>The selected cell index</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecellselect';
}
Ext.grid.CellSelectionModelEvents.get_cellselect = function Ext_grid_CellSelectionModelEvents$get_cellselect() {
    /// <summary>
    /// Fires when a cell is selected.
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis, {Number} rowIndex, {Number} colIndex)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The selected row index</description></item><item><term><b>colIndex</b></term><description>The selected cell index</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'cellselect';
}
Ext.grid.CellSelectionModelEvents.get_selectionchange = function Ext_grid_CellSelectionModelEvents$get_selectionchange() {
    /// <summary>
    /// Fires when the active selection changes.
    /// <ul><li>o.record: the record object for the row the selection is in</li><li>o.cell: An array of [rowIndex, columnIndex]</li></ul><pre><code>
    /// USAGE: ({SelectionModel} objthis, {Object} selection)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>selection</b></term><description>null for no selection or an object (o) with two properties</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'selectionchange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.CheckboxSelectionModelConfig

Ext.grid.CheckboxSelectionModelConfig = function Ext_grid_CheckboxSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.CheckboxSelectionModelConfig.prototype = {
    
    header: function Ext_grid_CheckboxSelectionModelConfig$header(value) {
        /// <summary>
        /// Any valid text or HTML fragment to display in the header cell for the checkbox column (defaults to '&lt;div class="x-grid3-hd-checker"&gt;�&lt;/div&gt;').  The default CSS class of 'x-grid3-hd-checker' displays a checkbox in the header and provides support for automatic check all/none behavior on header click. This string can be replaced by any valid HTML fragment, including a simple text string (e.g., 'Select Rows'), but the automatic check all/none behavior will only work if the 'x-grid3-hd-checker' class is supplied.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    width: function Ext_grid_CheckboxSelectionModelConfig$width(value) {
        /// <summary>
        /// The default width in pixels of the checkbox column (defaults to 20).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    sortable: function Ext_grid_CheckboxSelectionModelConfig$sortable(value) {
        /// <summary>
        /// True if the checkbox column is sortable (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['sortable'] = value;
        return this;
    },
    
    singleSelect: function Ext_grid_CheckboxSelectionModelConfig$singleSelect(value) {
        /// <summary>
        /// True to allow selection of only one row at a time (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['singleSelect'] = value;
        return this;
    },
    
    moveEditorOnEnter: function Ext_grid_CheckboxSelectionModelConfig$moveEditorOnEnter(value) {
        /// <summary>
        /// False to turn off moving the editor to the next cell when the enter key is pressed
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['moveEditorOnEnter'] = value;
        return this;
    },
    
    listeners: function Ext_grid_CheckboxSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_CheckboxSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.CheckboxSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_CheckboxSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.ColumnModelConfig

Ext.grid.ColumnModelConfig = function Ext_grid_ColumnModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.ColumnModelConfig.prototype = {
    
    id: function Ext_grid_ColumnModelConfig$id(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    header: function Ext_grid_ColumnModelConfig$header(value) {
        /// <summary>
        /// The header text to display in the Grid view.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    dataIndex: function Ext_grid_ColumnModelConfig$dataIndex(value) {
        /// <summary>
        /// (optional) The name of the field in the grid's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from which to draw the column's value. If not specified, the column's index is used as an index into the Record's data Array.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['dataIndex'] = value;
        return this;
    },
    
    width: function Ext_grid_ColumnModelConfig$width(value) {
        /// <summary>
        /// (optional) The initial width in pixels of the column. Using this instead of {@link Ext.grid.GridPanel#autoSizeColumns} is more efficient.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    sortable: function Ext_grid_ColumnModelConfig$sortable(value) {
        /// <summary>
        /// (optional) True if sorting is to be allowed on this column. Defaults to the value of the {@link #defaultSortable} property. Whether local/remote sorting is used is specified in {@link Ext.data.Store#remoteSort}.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['sortable'] = value;
        return this;
    },
    
    fixed_: function Ext_grid_ColumnModelConfig$fixed_(value) {
        /// <summary>
        /// (optional) True if the column width cannot be changed.  Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['fixed'] = value;
        return this;
    },
    
    resizable: function Ext_grid_ColumnModelConfig$resizable(value) {
        /// <summary>
        /// (optional) False to disable column resizing. Defaults to true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    menuDisabled: function Ext_grid_ColumnModelConfig$menuDisabled(value) {
        /// <summary>
        /// (optional) True to disable the column menu. Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['menuDisabled'] = value;
        return this;
    },
    
    hidden: function Ext_grid_ColumnModelConfig$hidden(value) {
        /// <summary>
        /// (optional) True to hide the column. Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    tooltip: function Ext_grid_ColumnModelConfig$tooltip(value) {
        /// <summary>
        /// (optional) A text string to use as the column header's tooltip.  If Quicktips are enabled, this value will be used as the text of the quick tip, otherwise it will be set as the header's HTML title attribute. Defaults to ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    renderer: function Ext_grid_ColumnModelConfig$renderer(value) {
        /// <summary>
        /// (optional) A function used to generate HTML markup for a cell given the cell's data value. See {@link #setRenderer}. If not specified, the default renderer uses the raw data value.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['renderer'] = value;
        return this;
    },
    
    align: function Ext_grid_ColumnModelConfig$align(value) {
        /// <summary>
        /// (optional) Set the CSS text-align property of the column.  Defaults to undefined.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['align'] = value;
        return this;
    },
    
    css: function Ext_grid_ColumnModelConfig$css(value) {
        /// <summary>
        /// (optional) Set custom CSS for all table cells in the column (excluding headers).  Defaults to undefined.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['css'] = value;
        return this;
    },
    
    hideable: function Ext_grid_ColumnModelConfig$hideable(value) {
        /// <summary>
        /// (optional) Specify as <tt>false</tt> to prevent the user from hiding this column.  Defaults to true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['hideable'] = value;
        return this;
    },
    
    editor: function Ext_grid_ColumnModelConfig$editor(value) {
        /// <summary>
        /// (optional) The {@link Ext.form.Field} to use when editing values in this column if editing is supported by the grid.
        /// </summary>
        /// <param name="value" type="Ext.form.Field">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['editor'] = value;
        return this;
    },
    
    listeners: function Ext_grid_ColumnModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_ColumnModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.ColumnModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_ColumnModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.ColumnModelEvents

Ext.grid.ColumnModelEvents = function Ext_grid_ColumnModelEvents() {
}
Ext.grid.ColumnModelEvents.get_widthchange = function Ext_grid_ColumnModelEvents$get_widthchange() {
    /// <summary>
    /// Fires when the width of a column changes.
    /// <pre><code>
    /// USAGE: ({ColumnModel} objthis, {Number} columnIndex, {Number} newWidth)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description>The column index</description></item><item><term><b>newWidth</b></term><description>The new width</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'widthchange';
}
Ext.grid.ColumnModelEvents.get_headerchange = function Ext_grid_ColumnModelEvents$get_headerchange() {
    /// <summary>
    /// Fires when the text of a header changes.
    /// <pre><code>
    /// USAGE: ({ColumnModel} objthis, {Number} columnIndex, {String} newText)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description>The column index</description></item><item><term><b>newText</b></term><description>The new header text</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'headerchange';
}
Ext.grid.ColumnModelEvents.get_hiddenchange = function Ext_grid_ColumnModelEvents$get_hiddenchange() {
    /// <summary>
    /// Fires when a column is hidden or "unhidden".
    /// <pre><code>
    /// USAGE: ({ColumnModel} objthis, {Number} columnIndex, {Boolean} hidden)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description>The column index</description></item><item><term><b>hidden</b></term><description>true if hidden, false otherwise</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'hiddenchange';
}
Ext.grid.ColumnModelEvents.get_columnmoved = function Ext_grid_ColumnModelEvents$get_columnmoved() {
    /// <summary>
    /// Fires when a column is moved.
    /// <pre><code>
    /// USAGE: ({ColumnModel} objthis, {Number} oldIndex, {Number} newIndex)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>oldIndex</b></term><description></description></item><item><term><b>newIndex</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'columnmoved';
}
Ext.grid.ColumnModelEvents.get_configchanged = function Ext_grid_ColumnModelEvents$get_configchanged() {
    /// <summary>
    /// Fires when the configuration is changed
    /// <pre><code>
    /// USAGE: ({ColumnModel} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'configchanged';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.EditorGridPanelConfig

Ext.grid.EditorGridPanelConfig = function Ext_grid_EditorGridPanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.EditorGridPanelConfig.prototype = {
    
    clicksToEdit: function Ext_grid_EditorGridPanelConfig$clicksToEdit(value) {
        /// <summary>
        /// The number of clicks on a cell required to display the cell's editor (defaults to 2)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['clicksToEdit'] = value;
        return this;
    },
    
    autoEncode: function Ext_grid_EditorGridPanelConfig$autoEncode(value) {
        /// <summary>
        /// True to automatically HTML encode and decode values pre and post edit (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoEncode'] = value;
        return this;
    },
    
    selModel: function Ext_grid_EditorGridPanelConfig$selModel(value) {
        /// <summary>
        /// Any subclass of AbstractSelectionModel that will provide the selection model for the grid (defaults to {@link Ext.grid.CellSelectionModel} if not specified).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['selModel'] = value;
        return this;
    },
    
    store: function Ext_grid_EditorGridPanelConfig$store(value) {
        /// <summary>
        /// The {@link Ext.data.Store} the grid should use as its data source (required).
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    cm: function Ext_grid_EditorGridPanelConfig$cm(value) {
        /// <summary>
        /// Shorthand for {@link #colModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['cm'] = value;
        return this;
    },
    
    colModel: function Ext_grid_EditorGridPanelConfig$colModel(value) {
        /// <summary>
        /// The {@link Ext.grid.ColumnModel} to use when rendering the grid (required).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['colModel'] = value;
        return this;
    },
    
    sm: function Ext_grid_EditorGridPanelConfig$sm(value) {
        /// <summary>
        /// Shorthand for {@link #selModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['sm'] = value;
        return this;
    },
    
    columns: function Ext_grid_EditorGridPanelConfig$columns(value) {
        /// <summary>
        /// An array of columns to auto create a ColumnModel
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['columns'] = value;
        return this;
    },
    
    maxHeight: function Ext_grid_EditorGridPanelConfig$maxHeight(value) {
        /// <summary>
        /// Sets the maximum height of the grid - ignored if autoHeight is not on.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    disableSelection: function Ext_grid_EditorGridPanelConfig$disableSelection(value) {
        /// <summary>
        /// True to disable selections in the grid (defaults to false). - ignored if a SelectionModel is specified
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['disableSelection'] = value;
        return this;
    },
    
    enableColumnMove: function Ext_grid_EditorGridPanelConfig$enableColumnMove(value) {
        /// <summary>
        /// False to turn off column reordering via drag drop (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['enableColumnMove'] = value;
        return this;
    },
    
    enableColumnResize: function Ext_grid_EditorGridPanelConfig$enableColumnResize(value) {
        /// <summary>
        /// False to turn off column resizing for the whole grid (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['enableColumnResize'] = value;
        return this;
    },
    
    viewConfig: function Ext_grid_EditorGridPanelConfig$viewConfig(value) {
        /// <summary>
        /// A config object that will be applied to the grid's UI view.  Any of the config options available for {@link Ext.grid.GridView} can be specified here.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['viewConfig'] = value;
        return this;
    },
    
    hideHeaders: function Ext_grid_EditorGridPanelConfig$hideHeaders(value) {
        /// <summary>
        /// True to hide the grid's header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['hideHeaders'] = value;
        return this;
    },
    
    minColumnWidth: function Ext_grid_EditorGridPanelConfig$minColumnWidth(value) {
        /// <summary>
        /// The minimum width a column can be resized to. Defaults to 25.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['minColumnWidth'] = value;
        return this;
    },
    
    trackMouseOver: function Ext_grid_EditorGridPanelConfig$trackMouseOver(value) {
        /// <summary>
        /// True to highlight rows when the mouse is over. Default is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['trackMouseOver'] = value;
        return this;
    },
    
    enableDragDrop: function Ext_grid_EditorGridPanelConfig$enableDragDrop(value) {
        /// <summary>
        /// True to enable drag and drop of rows.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['enableDragDrop'] = value;
        return this;
    },
    
    enableColumnHide: function Ext_grid_EditorGridPanelConfig$enableColumnHide(value) {
        /// <summary>
        /// True to enable hiding of columns with the header context menu.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['enableColumnHide'] = value;
        return this;
    },
    
    enableHdMenu: function Ext_grid_EditorGridPanelConfig$enableHdMenu(value) {
        /// <summary>
        /// True to enable the drop down button for menu in the headers.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['enableHdMenu'] = value;
        return this;
    },
    
    stripeRows: function Ext_grid_EditorGridPanelConfig$stripeRows(value) {
        /// <summary>
        /// True to stripe the rows. Default is false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['stripeRows'] = value;
        return this;
    },
    
    autoExpandColumn: function Ext_grid_EditorGridPanelConfig$autoExpandColumn(value) {
        /// <summary>
        /// The id of a column in this grid that should expand to fill unused space. This id can not be 0.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoExpandColumn'] = value;
        return this;
    },
    
    autoExpandMin: function Ext_grid_EditorGridPanelConfig$autoExpandMin(value) {
        /// <summary>
        /// The minimum width the autoExpandColumn can have (if enabled). defaults to 50.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoExpandMin'] = value;
        return this;
    },
    
    autoExpandMax: function Ext_grid_EditorGridPanelConfig$autoExpandMax(value) {
        /// <summary>
        /// The maximum width the autoExpandColumn can have (if enabled). Defaults to 1000.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoExpandMax'] = value;
        return this;
    },
    
    view: function Ext_grid_EditorGridPanelConfig$view(value) {
        /// <summary>
        /// The {@link Ext.grid.GridView} used by the grid. This can be set before a call to render().
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['view'] = value;
        return this;
    },
    
    loadMask: function Ext_grid_EditorGridPanelConfig$loadMask(value) {
        /// <summary>
        /// An {@link Ext.LoadMask} config or true to mask the grid while loading (defaults to false).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['loadMask'] = value;
        return this;
    },
    
    applyTo: function Ext_grid_EditorGridPanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_grid_EditorGridPanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_grid_EditorGridPanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_grid_EditorGridPanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_grid_EditorGridPanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_grid_EditorGridPanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_grid_EditorGridPanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_grid_EditorGridPanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_grid_EditorGridPanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_grid_EditorGridPanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_grid_EditorGridPanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_grid_EditorGridPanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_grid_EditorGridPanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_grid_EditorGridPanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_grid_EditorGridPanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_grid_EditorGridPanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_grid_EditorGridPanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_grid_EditorGridPanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_grid_EditorGridPanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_grid_EditorGridPanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_grid_EditorGridPanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_grid_EditorGridPanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_grid_EditorGridPanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_grid_EditorGridPanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_grid_EditorGridPanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_grid_EditorGridPanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_grid_EditorGridPanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_grid_EditorGridPanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_grid_EditorGridPanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_grid_EditorGridPanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_grid_EditorGridPanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_grid_EditorGridPanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_grid_EditorGridPanelConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_grid_EditorGridPanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_grid_EditorGridPanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_grid_EditorGridPanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_grid_EditorGridPanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_grid_EditorGridPanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_grid_EditorGridPanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_grid_EditorGridPanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_grid_EditorGridPanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_grid_EditorGridPanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_grid_EditorGridPanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_grid_EditorGridPanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_grid_EditorGridPanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_grid_EditorGridPanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_grid_EditorGridPanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_grid_EditorGridPanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_grid_EditorGridPanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_grid_EditorGridPanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_grid_EditorGridPanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_grid_EditorGridPanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_grid_EditorGridPanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_grid_EditorGridPanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_grid_EditorGridPanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_grid_EditorGridPanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_grid_EditorGridPanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_grid_EditorGridPanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_grid_EditorGridPanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_grid_EditorGridPanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_grid_EditorGridPanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_grid_EditorGridPanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_grid_EditorGridPanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_grid_EditorGridPanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_grid_EditorGridPanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_grid_EditorGridPanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_grid_EditorGridPanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_grid_EditorGridPanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_grid_EditorGridPanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    ds: function Ext_grid_EditorGridPanelConfig$ds(value) {
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['ds'] = value;
        return this;
    },
    
    el: function Ext_grid_EditorGridPanelConfig$el(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o['el'] = value;
        return this;
    },
    
    custom: function Ext_grid_EditorGridPanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.EditorGridPanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_EditorGridPanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.EditorGridPanelEvents

Ext.grid.EditorGridPanelEvents = function Ext_grid_EditorGridPanelEvents() {
}
Ext.grid.EditorGridPanelEvents.get_beforeedit = function Ext_grid_EditorGridPanelEvents$get_beforeedit() {
    /// <summary>
    /// Fires before cell editing is triggered. The edit event object has the following properties <br /><ul style="padding:5px;padding-left:16px;"><li>grid - This grid</li><li>record - The record being edited</li><li>field - The field name being edited</li><li>value - The value for the field being edited.</li><li>row - The grid row index</li><li>column - The grid column index</li><li>cancel - Set this to true to cancel the edit or return false from your handler.</li></ul><pre><code>
    /// USAGE: ({Object} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description>An edit event (see above for description)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeedit';
}
Ext.grid.EditorGridPanelEvents.get_afteredit = function Ext_grid_EditorGridPanelEvents$get_afteredit() {
    /// <summary>
    /// Fires after a cell is edited. <br /><ul style="padding:5px;padding-left:16px;"><li>grid - This grid</li><li>record - The record being edited</li><li>field - The field name being edited</li><li>value - The value being set</li><li>originalValue - The original value for the field, before the edit.</li><li>row - The grid row index</li><li>column - The grid column index</li></ul><pre><code>
    /// USAGE: ({Object} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description>An edit event (see above for description)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'afteredit';
}
Ext.grid.EditorGridPanelEvents.get_validateedit = function Ext_grid_EditorGridPanelEvents$get_validateedit() {
    /// <summary>
    /// Fires after a cell is edited, but before the value is set in the record. Return false
    /// to cancel the change. The edit event object has the following properties <br /><ul style="padding:5px;padding-left:16px;"><li>grid - This grid</li><li>record - The record being edited</li><li>field - The field name being edited</li><li>value - The value being set</li><li>originalValue - The original value for the field, before the edit.</li><li>row - The grid row index</li><li>column - The grid column index</li><li>cancel - Set this to true to cancel the edit or return false from your handler.</li></ul><pre><code>
    /// USAGE: ({Object} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description>An edit event (see above for description)</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'validateedit';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.GridPanelConfig

Ext.grid.GridPanelConfig = function Ext_grid_GridPanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.GridPanelConfig.prototype = {
    
    store: function Ext_grid_GridPanelConfig$store(value) {
        /// <summary>
        /// The {@link Ext.data.Store} the grid should use as its data source (required).
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    cm: function Ext_grid_GridPanelConfig$cm(value) {
        /// <summary>
        /// Shorthand for {@link #colModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['cm'] = value;
        return this;
    },
    
    colModel: function Ext_grid_GridPanelConfig$colModel(value) {
        /// <summary>
        /// The {@link Ext.grid.ColumnModel} to use when rendering the grid (required).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['colModel'] = value;
        return this;
    },
    
    sm: function Ext_grid_GridPanelConfig$sm(value) {
        /// <summary>
        /// Shorthand for {@link #selModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['sm'] = value;
        return this;
    },
    
    selModel: function Ext_grid_GridPanelConfig$selModel(value) {
        /// <summary>
        /// Any subclass of AbstractSelectionModel that will provide the selection model for the grid (defaults to {@link Ext.grid.RowSelectionModel} if not specified).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['selModel'] = value;
        return this;
    },
    
    columns: function Ext_grid_GridPanelConfig$columns(value) {
        /// <summary>
        /// An array of columns to auto create a ColumnModel
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['columns'] = value;
        return this;
    },
    
    maxHeight: function Ext_grid_GridPanelConfig$maxHeight(value) {
        /// <summary>
        /// Sets the maximum height of the grid - ignored if autoHeight is not on.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    disableSelection: function Ext_grid_GridPanelConfig$disableSelection(value) {
        /// <summary>
        /// True to disable selections in the grid (defaults to false). - ignored if a SelectionModel is specified
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['disableSelection'] = value;
        return this;
    },
    
    enableColumnMove: function Ext_grid_GridPanelConfig$enableColumnMove(value) {
        /// <summary>
        /// False to turn off column reordering via drag drop (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['enableColumnMove'] = value;
        return this;
    },
    
    enableColumnResize: function Ext_grid_GridPanelConfig$enableColumnResize(value) {
        /// <summary>
        /// False to turn off column resizing for the whole grid (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['enableColumnResize'] = value;
        return this;
    },
    
    viewConfig: function Ext_grid_GridPanelConfig$viewConfig(value) {
        /// <summary>
        /// A config object that will be applied to the grid's UI view.  Any of the config options available for {@link Ext.grid.GridView} can be specified here.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['viewConfig'] = value;
        return this;
    },
    
    hideHeaders: function Ext_grid_GridPanelConfig$hideHeaders(value) {
        /// <summary>
        /// True to hide the grid's header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['hideHeaders'] = value;
        return this;
    },
    
    minColumnWidth: function Ext_grid_GridPanelConfig$minColumnWidth(value) {
        /// <summary>
        /// The minimum width a column can be resized to. Defaults to 25.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['minColumnWidth'] = value;
        return this;
    },
    
    trackMouseOver: function Ext_grid_GridPanelConfig$trackMouseOver(value) {
        /// <summary>
        /// True to highlight rows when the mouse is over. Default is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['trackMouseOver'] = value;
        return this;
    },
    
    enableDragDrop: function Ext_grid_GridPanelConfig$enableDragDrop(value) {
        /// <summary>
        /// True to enable drag and drop of rows.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['enableDragDrop'] = value;
        return this;
    },
    
    enableColumnHide: function Ext_grid_GridPanelConfig$enableColumnHide(value) {
        /// <summary>
        /// True to enable hiding of columns with the header context menu.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['enableColumnHide'] = value;
        return this;
    },
    
    enableHdMenu: function Ext_grid_GridPanelConfig$enableHdMenu(value) {
        /// <summary>
        /// True to enable the drop down button for menu in the headers.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['enableHdMenu'] = value;
        return this;
    },
    
    stripeRows: function Ext_grid_GridPanelConfig$stripeRows(value) {
        /// <summary>
        /// True to stripe the rows. Default is false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['stripeRows'] = value;
        return this;
    },
    
    autoExpandColumn: function Ext_grid_GridPanelConfig$autoExpandColumn(value) {
        /// <summary>
        /// The id of a column in this grid that should expand to fill unused space. This id can not be 0.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoExpandColumn'] = value;
        return this;
    },
    
    autoExpandMin: function Ext_grid_GridPanelConfig$autoExpandMin(value) {
        /// <summary>
        /// The minimum width the autoExpandColumn can have (if enabled). defaults to 50.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoExpandMin'] = value;
        return this;
    },
    
    autoExpandMax: function Ext_grid_GridPanelConfig$autoExpandMax(value) {
        /// <summary>
        /// The maximum width the autoExpandColumn can have (if enabled). Defaults to 1000.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoExpandMax'] = value;
        return this;
    },
    
    view: function Ext_grid_GridPanelConfig$view(value) {
        /// <summary>
        /// The {@link Ext.grid.GridView} used by the grid. This can be set before a call to render().
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['view'] = value;
        return this;
    },
    
    loadMask: function Ext_grid_GridPanelConfig$loadMask(value) {
        /// <summary>
        /// An {@link Ext.LoadMask} config or true to mask the grid while loading (defaults to false).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['loadMask'] = value;
        return this;
    },
    
    applyTo: function Ext_grid_GridPanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_grid_GridPanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_grid_GridPanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_grid_GridPanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_grid_GridPanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_grid_GridPanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_grid_GridPanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_grid_GridPanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_grid_GridPanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_grid_GridPanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_grid_GridPanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_grid_GridPanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_grid_GridPanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_grid_GridPanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_grid_GridPanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_grid_GridPanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_grid_GridPanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_grid_GridPanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_grid_GridPanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_grid_GridPanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_grid_GridPanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_grid_GridPanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_grid_GridPanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_grid_GridPanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_grid_GridPanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_grid_GridPanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_grid_GridPanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_grid_GridPanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_grid_GridPanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_grid_GridPanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_grid_GridPanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_grid_GridPanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_grid_GridPanelConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_grid_GridPanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_grid_GridPanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_grid_GridPanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_grid_GridPanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_grid_GridPanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_grid_GridPanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_grid_GridPanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_grid_GridPanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_grid_GridPanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_grid_GridPanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_grid_GridPanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_grid_GridPanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_grid_GridPanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_grid_GridPanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_grid_GridPanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_grid_GridPanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_grid_GridPanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_grid_GridPanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_grid_GridPanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_grid_GridPanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_grid_GridPanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_grid_GridPanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_grid_GridPanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_grid_GridPanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_grid_GridPanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_grid_GridPanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_grid_GridPanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_grid_GridPanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_grid_GridPanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_grid_GridPanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_grid_GridPanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_grid_GridPanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_grid_GridPanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_grid_GridPanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_grid_GridPanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_grid_GridPanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    ds: function Ext_grid_GridPanelConfig$ds(value) {
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['ds'] = value;
        return this;
    },
    
    el: function Ext_grid_GridPanelConfig$el(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o['el'] = value;
        return this;
    },
    
    custom: function Ext_grid_GridPanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridPanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_GridPanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.GridPanelEvents

Ext.grid.GridPanelEvents = function Ext_grid_GridPanelEvents() {
}
Ext.grid.GridPanelEvents.get_click = function Ext_grid_GridPanelEvents$get_click() {
    /// <summary>
    /// The raw click event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.grid.GridPanelEvents.get_dblclick = function Ext_grid_GridPanelEvents$get_dblclick() {
    /// <summary>
    /// The raw dblclick event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dblclick';
}
Ext.grid.GridPanelEvents.get_contextmenu = function Ext_grid_GridPanelEvents$get_contextmenu() {
    /// <summary>
    /// The raw contextmenu event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'contextmenu';
}
Ext.grid.GridPanelEvents.get_mousedown = function Ext_grid_GridPanelEvents$get_mousedown() {
    /// <summary>
    /// The raw mousedown event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mousedown';
}
Ext.grid.GridPanelEvents.get_mouseup = function Ext_grid_GridPanelEvents$get_mouseup() {
    /// <summary>
    /// The raw mouseup event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseup';
}
Ext.grid.GridPanelEvents.get_mouseover = function Ext_grid_GridPanelEvents$get_mouseover() {
    /// <summary>
    /// The raw mouseover event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseover';
}
Ext.grid.GridPanelEvents.get_mouseout = function Ext_grid_GridPanelEvents$get_mouseout() {
    /// <summary>
    /// The raw mouseout event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseout';
}
Ext.grid.GridPanelEvents.get_keypress = function Ext_grid_GridPanelEvents$get_keypress() {
    /// <summary>
    /// The raw keypress event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'keypress';
}
Ext.grid.GridPanelEvents.get_keydown = function Ext_grid_GridPanelEvents$get_keydown() {
    /// <summary>
    /// The raw keydown event for the entire grid.
    /// <pre><code>
    /// USAGE: ({Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'keydown';
}
Ext.grid.GridPanelEvents.get_cellmousedown = function Ext_grid_GridPanelEvents$get_cellmousedown() {
    /// <summary>
    /// Fires before a cell is clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'cellmousedown';
}
Ext.grid.GridPanelEvents.get_rowmousedown = function Ext_grid_GridPanelEvents$get_rowmousedown() {
    /// <summary>
    /// Fires before a row is clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowmousedown';
}
Ext.grid.GridPanelEvents.get_headermousedown = function Ext_grid_GridPanelEvents$get_headermousedown() {
    /// <summary>
    /// Fires before a header is clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'headermousedown';
}
Ext.grid.GridPanelEvents.get_cellclick = function Ext_grid_GridPanelEvents$get_cellclick() {
    /// <summary>
    /// Fires when a cell is clicked.
    /// The data for the cell is drawn from the {@link Ext.data.Record Record}
    /// for this row. To access the data in the listener function use the
    /// following technique:
    /// <pre><code>
    /// function(grid, rowIndex, columnIndex, e) {
    /// var record = grid.getStore().getAt(rowIndex);  // Get the Record
    /// var fieldName = grid.getColumnModel().getDataIndex(columnIndex); // Get field name
    /// var data = record.get(fieldName);
    /// }
    /// </code></pre><pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'cellclick';
}
Ext.grid.GridPanelEvents.get_celldblclick = function Ext_grid_GridPanelEvents$get_celldblclick() {
    /// <summary>
    /// Fires when a cell is double clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'celldblclick';
}
Ext.grid.GridPanelEvents.get_rowclick = function Ext_grid_GridPanelEvents$get_rowclick() {
    /// <summary>
    /// Fires when a row is clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowclick';
}
Ext.grid.GridPanelEvents.get_rowdblclick = function Ext_grid_GridPanelEvents$get_rowdblclick() {
    /// <summary>
    /// Fires when a row is double clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowdblclick';
}
Ext.grid.GridPanelEvents.get_headerclick = function Ext_grid_GridPanelEvents$get_headerclick() {
    /// <summary>
    /// Fires when a header is clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'headerclick';
}
Ext.grid.GridPanelEvents.get_headerdblclick = function Ext_grid_GridPanelEvents$get_headerdblclick() {
    /// <summary>
    /// Fires when a header cell is double clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'headerdblclick';
}
Ext.grid.GridPanelEvents.get_rowcontextmenu = function Ext_grid_GridPanelEvents$get_rowcontextmenu() {
    /// <summary>
    /// Fires when a row is right clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowcontextmenu';
}
Ext.grid.GridPanelEvents.get_cellcontextmenu = function Ext_grid_GridPanelEvents$get_cellcontextmenu() {
    /// <summary>
    /// Fires when a cell is right clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} rowIndex, {Number} cellIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>cellIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'cellcontextmenu';
}
Ext.grid.GridPanelEvents.get_headercontextmenu = function Ext_grid_GridPanelEvents$get_headercontextmenu() {
    /// <summary>
    /// Fires when a header is right clicked
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Number} columnIndex, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>columnIndex</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'headercontextmenu';
}
Ext.grid.GridPanelEvents.get_bodyscroll = function Ext_grid_GridPanelEvents$get_bodyscroll() {
    /// <summary>
    /// Fires when the body element is scrolled
    /// <pre><code>
    /// USAGE: ({Number} scrollLeft, {Number} scrollTop)
    /// </code></pre><list type="bullet"><item><term><b>scrollLeft</b></term><description></description></item><item><term><b>scrollTop</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'bodyscroll';
}
Ext.grid.GridPanelEvents.get_columnresize = function Ext_grid_GridPanelEvents$get_columnresize() {
    /// <summary>
    /// Fires when the user resizes a column
    /// <pre><code>
    /// USAGE: ({Number} columnIndex, {Number} newSize)
    /// </code></pre><list type="bullet"><item><term><b>columnIndex</b></term><description></description></item><item><term><b>newSize</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'columnresize';
}
Ext.grid.GridPanelEvents.get_columnmove = function Ext_grid_GridPanelEvents$get_columnmove() {
    /// <summary>
    /// Fires when the user moves a column
    /// <pre><code>
    /// USAGE: ({Number} oldIndex, {Number} newIndex)
    /// </code></pre><list type="bullet"><item><term><b>oldIndex</b></term><description></description></item><item><term><b>newIndex</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'columnmove';
}
Ext.grid.GridPanelEvents.get_sortchange = function Ext_grid_GridPanelEvents$get_sortchange() {
    /// <summary>
    /// Fires when the grid's store sort changes
    /// <pre><code>
    /// USAGE: ({Grid} objthis, {Object} sortInfo)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>sortInfo</b></term><description>An object with the keys field and direction</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'sortchange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.GridViewConfig

Ext.grid.GridViewConfig = function Ext_grid_GridViewConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.GridViewConfig.prototype = {
    
    enableRowBody: function Ext_grid_GridViewConfig$enableRowBody(value) {
        /// <summary>
        /// True to add a second TR element per row that can be used to provide a row body that spans beneath the data row.  Use the {@link #getRowClass} method's rowParams config to customize the row body.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['enableRowBody'] = value;
        return this;
    },
    
    emptyText: function Ext_grid_GridViewConfig$emptyText(value) {
        /// <summary>
        /// Default text to display in the grid body when no rows are available (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    deferEmptyText: function Ext_grid_GridViewConfig$deferEmptyText(value) {
        /// <summary>
        /// True to defer emptyText being applied until the store's first load
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['deferEmptyText'] = value;
        return this;
    },
    
    autoFill: function Ext_grid_GridViewConfig$autoFill(value) {
        /// <summary>
        /// True to auto expand the columns to fit the grid <b>when the grid is created</b>.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['autoFill'] = value;
        return this;
    },
    
    forceFit: function Ext_grid_GridViewConfig$forceFit(value) {
        /// <summary>
        /// True to auto expand/contract the size of the columns to fit the grid width and prevent horizontal scrolling.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['forceFit'] = value;
        return this;
    },
    
    listeners: function Ext_grid_GridViewConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    getRowClass: function Ext_grid_GridViewConfig$getRowClass(value) {
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o['getRowClass'] = value;
        return this;
    },
    
    custom: function Ext_grid_GridViewConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GridViewConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_GridViewConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.GridViewEvents

Ext.grid.GridViewEvents = function Ext_grid_GridViewEvents() {
}
Ext.grid.GridViewEvents.get_beforerowremoved = function Ext_grid_GridViewEvents$get_beforerowremoved() {
    /// <summary>
    /// Internal UI Event. Fired before a row is removed.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view, {Number} rowIndex, {Ext.data.Record} record)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The index of the row to be removed.</description></item><item><term><b>record</b></term><description>The Record to be removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerowremoved';
}
Ext.grid.GridViewEvents.get_beforerowsinserted = function Ext_grid_GridViewEvents$get_beforerowsinserted() {
    /// <summary>
    /// Internal UI Event. Fired before rows are inserted.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view, {Number} firstRow, {Number} lastRow)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item><item><term><b>firstRow</b></term><description>The index of the first row to be inserted.</description></item><item><term><b>lastRow</b></term><description>The index of the last row to be inserted.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerowsinserted';
}
Ext.grid.GridViewEvents.get_beforerefresh = function Ext_grid_GridViewEvents$get_beforerefresh() {
    /// <summary>
    /// Internal UI Event. Fired before the view is refreshed.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerefresh';
}
Ext.grid.GridViewEvents.get_rowremoved = function Ext_grid_GridViewEvents$get_rowremoved() {
    /// <summary>
    /// Internal UI Event. Fired after a row is removed.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view, {Number} rowIndex, {Ext.data.Record} record)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The index of the row that was removed.</description></item><item><term><b>record</b></term><description>The Record that was removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowremoved';
}
Ext.grid.GridViewEvents.get_rowsinserted = function Ext_grid_GridViewEvents$get_rowsinserted() {
    /// <summary>
    /// Internal UI Event. Fired after rows are inserted.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view, {Number} firstRow, {Number} lastRow)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item><item><term><b>firstRow</b></term><description>The index of the first inserted.</description></item><item><term><b>lastRow</b></term><description>The index of the last row inserted.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowsinserted';
}
Ext.grid.GridViewEvents.get_rowupdated = function Ext_grid_GridViewEvents$get_rowupdated() {
    /// <summary>
    /// Internal UI Event. Fired after a row has been updated.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view, {Number} firstRow, {Ext.data.record} record)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item><item><term><b>firstRow</b></term><description>The index of the row updated.</description></item><item><term><b>record</b></term><description>The Record backing the row updated.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowupdated';
}
Ext.grid.GridViewEvents.get_refresh = function Ext_grid_GridViewEvents$get_refresh() {
    /// <summary>
    /// Internal UI Event. Fired after the GridView's body has been refreshed.
    /// <pre><code>
    /// USAGE: ({Ext.grid.GridView} view)
    /// </code></pre><list type="bullet"><item><term><b>view</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'refresh';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.GroupingViewConfig

Ext.grid.GroupingViewConfig = function Ext_grid_GroupingViewConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.GroupingViewConfig.prototype = {
    
    hideGroupedColumn: function Ext_grid_GroupingViewConfig$hideGroupedColumn(value) {
        /// <summary>
        /// True to hide the column that is currently grouped
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['hideGroupedColumn'] = value;
        return this;
    },
    
    showGroupName: function Ext_grid_GroupingViewConfig$showGroupName(value) {
        /// <summary>
        /// True to display the name for each set of grouped rows (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['showGroupName'] = value;
        return this;
    },
    
    startCollapsed: function Ext_grid_GroupingViewConfig$startCollapsed(value) {
        /// <summary>
        /// True to start all groups collapsed
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['startCollapsed'] = value;
        return this;
    },
    
    enableGrouping: function Ext_grid_GroupingViewConfig$enableGrouping(value) {
        /// <summary>
        /// False to disable grouping functionality (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['enableGrouping'] = value;
        return this;
    },
    
    enableGroupingMenu: function Ext_grid_GroupingViewConfig$enableGroupingMenu(value) {
        /// <summary>
        /// True to enable the grouping control in the column menu
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['enableGroupingMenu'] = value;
        return this;
    },
    
    enableNoGroups: function Ext_grid_GroupingViewConfig$enableNoGroups(value) {
        /// <summary>
        /// True to allow the user to turn off grouping
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['enableNoGroups'] = value;
        return this;
    },
    
    emptyGroupText: function Ext_grid_GroupingViewConfig$emptyGroupText(value) {
        /// <summary>
        /// The text to display when there is an empty group value
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['emptyGroupText'] = value;
        return this;
    },
    
    ignoreAdd: function Ext_grid_GroupingViewConfig$ignoreAdd(value) {
        /// <summary>
        /// True to skip refreshing the view when new rows are added (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['ignoreAdd'] = value;
        return this;
    },
    
    groupTextTpl: function Ext_grid_GroupingViewConfig$groupTextTpl(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['groupTextTpl'] = value;
        return this;
    },
    
    groupRenderer: function Ext_grid_GroupingViewConfig$groupRenderer(value) {
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['groupRenderer'] = value;
        return this;
    },
    
    header: function Ext_grid_GroupingViewConfig$header(value) {
        /// <summary>
        /// The text with which to prefix the group field value in the group header line.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    groupByText: function Ext_grid_GroupingViewConfig$groupByText(value) {
        /// <summary>
        /// Text displayed in the grid header menu for grouping by a column (defaults to 'Group By This Field').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['groupByText'] = value;
        return this;
    },
    
    showGroupsText: function Ext_grid_GroupingViewConfig$showGroupsText(value) {
        /// <summary>
        /// Text displayed in the grid header for enabling/disabling grouping (defaults to 'Show in Groups').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['showGroupsText'] = value;
        return this;
    },
    
    enableRowBody: function Ext_grid_GroupingViewConfig$enableRowBody(value) {
        /// <summary>
        /// True to add a second TR element per row that can be used to provide a row body that spans beneath the data row.  Use the {@link #getRowClass} method's rowParams config to customize the row body.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['enableRowBody'] = value;
        return this;
    },
    
    emptyText: function Ext_grid_GroupingViewConfig$emptyText(value) {
        /// <summary>
        /// Default text to display in the grid body when no rows are available (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    deferEmptyText: function Ext_grid_GroupingViewConfig$deferEmptyText(value) {
        /// <summary>
        /// True to defer emptyText being applied until the store's first load
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['deferEmptyText'] = value;
        return this;
    },
    
    autoFill: function Ext_grid_GroupingViewConfig$autoFill(value) {
        /// <summary>
        /// True to auto expand the columns to fit the grid <b>when the grid is created</b>.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['autoFill'] = value;
        return this;
    },
    
    forceFit: function Ext_grid_GroupingViewConfig$forceFit(value) {
        /// <summary>
        /// True to auto expand/contract the size of the columns to fit the grid width and prevent horizontal scrolling.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['forceFit'] = value;
        return this;
    },
    
    listeners: function Ext_grid_GroupingViewConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_GroupingViewConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.GroupingViewConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_GroupingViewConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.PropertyColumnModelConfig

Ext.grid.PropertyColumnModelConfig = function Ext_grid_PropertyColumnModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.PropertyColumnModelConfig.prototype = {
    
    id: function Ext_grid_PropertyColumnModelConfig$id(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    header: function Ext_grid_PropertyColumnModelConfig$header(value) {
        /// <summary>
        /// The header text to display in the Grid view.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    dataIndex: function Ext_grid_PropertyColumnModelConfig$dataIndex(value) {
        /// <summary>
        /// (optional) The name of the field in the grid's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from which to draw the column's value. If not specified, the column's index is used as an index into the Record's data Array.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['dataIndex'] = value;
        return this;
    },
    
    width: function Ext_grid_PropertyColumnModelConfig$width(value) {
        /// <summary>
        /// (optional) The initial width in pixels of the column. Using this instead of {@link Ext.grid.GridPanel#autoSizeColumns} is more efficient.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    sortable: function Ext_grid_PropertyColumnModelConfig$sortable(value) {
        /// <summary>
        /// (optional) True if sorting is to be allowed on this column. Defaults to the value of the {@link #defaultSortable} property. Whether local/remote sorting is used is specified in {@link Ext.data.Store#remoteSort}.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['sortable'] = value;
        return this;
    },
    
    fixed_: function Ext_grid_PropertyColumnModelConfig$fixed_(value) {
        /// <summary>
        /// (optional) True if the column width cannot be changed.  Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['fixed'] = value;
        return this;
    },
    
    resizable: function Ext_grid_PropertyColumnModelConfig$resizable(value) {
        /// <summary>
        /// (optional) False to disable column resizing. Defaults to true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    menuDisabled: function Ext_grid_PropertyColumnModelConfig$menuDisabled(value) {
        /// <summary>
        /// (optional) True to disable the column menu. Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['menuDisabled'] = value;
        return this;
    },
    
    hidden: function Ext_grid_PropertyColumnModelConfig$hidden(value) {
        /// <summary>
        /// (optional) True to hide the column. Defaults to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    tooltip: function Ext_grid_PropertyColumnModelConfig$tooltip(value) {
        /// <summary>
        /// (optional) A text string to use as the column header's tooltip.  If Quicktips are enabled, this value will be used as the text of the quick tip, otherwise it will be set as the header's HTML title attribute. Defaults to ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    renderer: function Ext_grid_PropertyColumnModelConfig$renderer(value) {
        /// <summary>
        /// (optional) A function used to generate HTML markup for a cell given the cell's data value. See {@link #setRenderer}. If not specified, the default renderer uses the raw data value.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['renderer'] = value;
        return this;
    },
    
    align: function Ext_grid_PropertyColumnModelConfig$align(value) {
        /// <summary>
        /// (optional) Set the CSS text-align property of the column.  Defaults to undefined.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['align'] = value;
        return this;
    },
    
    css: function Ext_grid_PropertyColumnModelConfig$css(value) {
        /// <summary>
        /// (optional) Set custom CSS for all table cells in the column (excluding headers).  Defaults to undefined.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['css'] = value;
        return this;
    },
    
    hideable: function Ext_grid_PropertyColumnModelConfig$hideable(value) {
        /// <summary>
        /// (optional) Specify as <tt>false</tt> to prevent the user from hiding this column.  Defaults to true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['hideable'] = value;
        return this;
    },
    
    editor: function Ext_grid_PropertyColumnModelConfig$editor(value) {
        /// <summary>
        /// (optional) The {@link Ext.form.Field} to use when editing values in this column if editing is supported by the grid.
        /// </summary>
        /// <param name="value" type="Ext.form.Field">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['editor'] = value;
        return this;
    },
    
    listeners: function Ext_grid_PropertyColumnModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_PropertyColumnModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyColumnModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_PropertyColumnModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.PropertyGridConfig

Ext.grid.PropertyGridConfig = function Ext_grid_PropertyGridConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.PropertyGridConfig.prototype = {
    
    source: function Ext_grid_PropertyGridConfig$source(value) {
        /// <summary>
        /// A data object to use as the data source of the grid (see {@link #setSource} for details).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['source'] = value;
        return this;
    },
    
    customEditors: function Ext_grid_PropertyGridConfig$customEditors(value) {
        /// <summary>
        /// An object containing name/value pairs of custom editor type definitions that allow the grid to support additional types of editable fields.  By default, the grid supports strongly-typed editing of strings, dates, numbers and booleans using built-in form editors, but any custom type can be supported and associated with a custom input control by specifying a custom editor.  The name of the editor type should correspond with the name of the property that will use the editor.  Example usage: <pre><code> var grid = new Ext.grid.PropertyGrid({ ... customEditors: { 'Start Time': new Ext.grid.GridEditor(new Ext.form.TimeField({selectOnFocus:true})) }, source: { 'Start Time': '10:00 AM' } }); </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['customEditors'] = value;
        return this;
    },
    
    clicksToEdit: function Ext_grid_PropertyGridConfig$clicksToEdit(value) {
        /// <summary>
        /// The number of clicks on a cell required to display the cell's editor (defaults to 2)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['clicksToEdit'] = value;
        return this;
    },
    
    autoEncode: function Ext_grid_PropertyGridConfig$autoEncode(value) {
        /// <summary>
        /// True to automatically HTML encode and decode values pre and post edit (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoEncode'] = value;
        return this;
    },
    
    selModel: function Ext_grid_PropertyGridConfig$selModel(value) {
        /// <summary>
        /// Any subclass of AbstractSelectionModel that will provide the selection model for the grid (defaults to {@link Ext.grid.CellSelectionModel} if not specified).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['selModel'] = value;
        return this;
    },
    
    store: function Ext_grid_PropertyGridConfig$store(value) {
        /// <summary>
        /// The {@link Ext.data.Store} the grid should use as its data source (required).
        /// </summary>
        /// <param name="value" type="Ext.data.Store">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    cm: function Ext_grid_PropertyGridConfig$cm(value) {
        /// <summary>
        /// Shorthand for {@link #colModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['cm'] = value;
        return this;
    },
    
    colModel: function Ext_grid_PropertyGridConfig$colModel(value) {
        /// <summary>
        /// The {@link Ext.grid.ColumnModel} to use when rendering the grid (required).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['colModel'] = value;
        return this;
    },
    
    sm: function Ext_grid_PropertyGridConfig$sm(value) {
        /// <summary>
        /// Shorthand for {@link #selModel}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['sm'] = value;
        return this;
    },
    
    columns: function Ext_grid_PropertyGridConfig$columns(value) {
        /// <summary>
        /// An array of columns to auto create a ColumnModel
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['columns'] = value;
        return this;
    },
    
    maxHeight: function Ext_grid_PropertyGridConfig$maxHeight(value) {
        /// <summary>
        /// Sets the maximum height of the grid - ignored if autoHeight is not on.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    disableSelection: function Ext_grid_PropertyGridConfig$disableSelection(value) {
        /// <summary>
        /// True to disable selections in the grid (defaults to false). - ignored if a SelectionModel is specified
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['disableSelection'] = value;
        return this;
    },
    
    enableColumnMove: function Ext_grid_PropertyGridConfig$enableColumnMove(value) {
        /// <summary>
        /// False to turn off column reordering via drag drop (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['enableColumnMove'] = value;
        return this;
    },
    
    enableColumnResize: function Ext_grid_PropertyGridConfig$enableColumnResize(value) {
        /// <summary>
        /// False to turn off column resizing for the whole grid (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['enableColumnResize'] = value;
        return this;
    },
    
    viewConfig: function Ext_grid_PropertyGridConfig$viewConfig(value) {
        /// <summary>
        /// A config object that will be applied to the grid's UI view.  Any of the config options available for {@link Ext.grid.GridView} can be specified here.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['viewConfig'] = value;
        return this;
    },
    
    hideHeaders: function Ext_grid_PropertyGridConfig$hideHeaders(value) {
        /// <summary>
        /// True to hide the grid's header (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['hideHeaders'] = value;
        return this;
    },
    
    minColumnWidth: function Ext_grid_PropertyGridConfig$minColumnWidth(value) {
        /// <summary>
        /// The minimum width a column can be resized to. Defaults to 25.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['minColumnWidth'] = value;
        return this;
    },
    
    trackMouseOver: function Ext_grid_PropertyGridConfig$trackMouseOver(value) {
        /// <summary>
        /// True to highlight rows when the mouse is over. Default is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['trackMouseOver'] = value;
        return this;
    },
    
    enableDragDrop: function Ext_grid_PropertyGridConfig$enableDragDrop(value) {
        /// <summary>
        /// True to enable drag and drop of rows.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['enableDragDrop'] = value;
        return this;
    },
    
    enableColumnHide: function Ext_grid_PropertyGridConfig$enableColumnHide(value) {
        /// <summary>
        /// True to enable hiding of columns with the header context menu.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['enableColumnHide'] = value;
        return this;
    },
    
    enableHdMenu: function Ext_grid_PropertyGridConfig$enableHdMenu(value) {
        /// <summary>
        /// True to enable the drop down button for menu in the headers.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['enableHdMenu'] = value;
        return this;
    },
    
    stripeRows: function Ext_grid_PropertyGridConfig$stripeRows(value) {
        /// <summary>
        /// True to stripe the rows. Default is false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['stripeRows'] = value;
        return this;
    },
    
    autoExpandColumn: function Ext_grid_PropertyGridConfig$autoExpandColumn(value) {
        /// <summary>
        /// The id of a column in this grid that should expand to fill unused space. This id can not be 0.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoExpandColumn'] = value;
        return this;
    },
    
    autoExpandMin: function Ext_grid_PropertyGridConfig$autoExpandMin(value) {
        /// <summary>
        /// The minimum width the autoExpandColumn can have (if enabled). defaults to 50.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoExpandMin'] = value;
        return this;
    },
    
    autoExpandMax: function Ext_grid_PropertyGridConfig$autoExpandMax(value) {
        /// <summary>
        /// The maximum width the autoExpandColumn can have (if enabled). Defaults to 1000.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoExpandMax'] = value;
        return this;
    },
    
    view: function Ext_grid_PropertyGridConfig$view(value) {
        /// <summary>
        /// The {@link Ext.grid.GridView} used by the grid. This can be set before a call to render().
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['view'] = value;
        return this;
    },
    
    loadMask: function Ext_grid_PropertyGridConfig$loadMask(value) {
        /// <summary>
        /// An {@link Ext.LoadMask} config or true to mask the grid while loading (defaults to false).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['loadMask'] = value;
        return this;
    },
    
    applyTo: function Ext_grid_PropertyGridConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_grid_PropertyGridConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_grid_PropertyGridConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_grid_PropertyGridConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_grid_PropertyGridConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_grid_PropertyGridConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_grid_PropertyGridConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_grid_PropertyGridConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_grid_PropertyGridConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_grid_PropertyGridConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_grid_PropertyGridConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_grid_PropertyGridConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_grid_PropertyGridConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_grid_PropertyGridConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_grid_PropertyGridConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_grid_PropertyGridConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_grid_PropertyGridConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_grid_PropertyGridConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_grid_PropertyGridConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_grid_PropertyGridConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_grid_PropertyGridConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_grid_PropertyGridConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_grid_PropertyGridConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_grid_PropertyGridConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_grid_PropertyGridConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_grid_PropertyGridConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_grid_PropertyGridConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_grid_PropertyGridConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_grid_PropertyGridConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_grid_PropertyGridConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_grid_PropertyGridConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_grid_PropertyGridConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_grid_PropertyGridConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_grid_PropertyGridConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_grid_PropertyGridConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_grid_PropertyGridConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_grid_PropertyGridConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_grid_PropertyGridConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_grid_PropertyGridConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_grid_PropertyGridConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_grid_PropertyGridConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_grid_PropertyGridConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_grid_PropertyGridConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_grid_PropertyGridConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_grid_PropertyGridConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_grid_PropertyGridConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_grid_PropertyGridConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_grid_PropertyGridConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_grid_PropertyGridConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_grid_PropertyGridConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_grid_PropertyGridConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_grid_PropertyGridConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_grid_PropertyGridConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_grid_PropertyGridConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_grid_PropertyGridConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_grid_PropertyGridConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_grid_PropertyGridConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_grid_PropertyGridConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_grid_PropertyGridConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_grid_PropertyGridConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_grid_PropertyGridConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_grid_PropertyGridConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_grid_PropertyGridConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_grid_PropertyGridConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_grid_PropertyGridConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_grid_PropertyGridConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_grid_PropertyGridConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_grid_PropertyGridConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_grid_PropertyGridConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_PropertyGridConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyGridConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_PropertyGridConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.PropertyGridEvents

Ext.grid.PropertyGridEvents = function Ext_grid_PropertyGridEvents() {
}
Ext.grid.PropertyGridEvents.get_beforepropertychange = function Ext_grid_PropertyGridEvents$get_beforepropertychange() {
    /// <summary>
    /// Fires before a property value changes.  Handlers can return false to cancel the property change
    /// (this will internally call {@link Ext.data.Record#reject} on the property's record).
    /// as the {@link #source} config property).
    /// <pre><code>
    /// USAGE: ({Object} source, {String} recordId, {Mixed} value, {Mixed} oldValue)
    /// </code></pre><list type="bullet"><item><term><b>source</b></term><description>The source data object for the grid (corresponds to the same object passed in</description></item><item><term><b>recordId</b></term><description>The record's id in the data store</description></item><item><term><b>value</b></term><description>The current edited property value</description></item><item><term><b>oldValue</b></term><description>The original property value prior to editing</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforepropertychange';
}
Ext.grid.PropertyGridEvents.get_propertychange = function Ext_grid_PropertyGridEvents$get_propertychange() {
    /// <summary>
    /// Fires after a property value has changed.
    /// as the {@link #source} config property).
    /// <pre><code>
    /// USAGE: ({Object} source, {String} recordId, {Mixed} value, {Mixed} oldValue)
    /// </code></pre><list type="bullet"><item><term><b>source</b></term><description>The source data object for the grid (corresponds to the same object passed in</description></item><item><term><b>recordId</b></term><description>The record's id in the data store</description></item><item><term><b>value</b></term><description>The current edited property value</description></item><item><term><b>oldValue</b></term><description>The original property value prior to editing</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'propertychange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.PropertyRecordConfig

Ext.grid.PropertyRecordConfig = function Ext_grid_PropertyRecordConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.PropertyRecordConfig.prototype = {
    
    custom: function Ext_grid_PropertyRecordConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyRecordConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_PropertyRecordConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.PropertyStoreConfig

Ext.grid.PropertyStoreConfig = function Ext_grid_PropertyStoreConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.PropertyStoreConfig.prototype = {
    
    listeners: function Ext_grid_PropertyStoreConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyStoreConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_PropertyStoreConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.PropertyStoreConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_PropertyStoreConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.RowNumbererConfig

Ext.grid.RowNumbererConfig = function Ext_grid_RowNumbererConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.RowNumbererConfig.prototype = {
    
    header: function Ext_grid_RowNumbererConfig$header(value) {
        /// <summary>
        /// Any valid text or HTML fragment to display in the header cell for the row number column (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.grid.RowNumbererConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    width: function Ext_grid_RowNumbererConfig$width(value) {
        /// <summary>
        /// The default width in pixels of the row number column (defaults to 23).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.grid.RowNumbererConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    sortable: function Ext_grid_RowNumbererConfig$sortable(value) {
        /// <summary>
        /// True if the row number column is sortable (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.RowNumbererConfig"></returns>
        this.o['sortable'] = value;
        return this;
    },
    
    custom: function Ext_grid_RowNumbererConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.RowNumbererConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_RowNumbererConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.RowSelectionModelConfig

Ext.grid.RowSelectionModelConfig = function Ext_grid_RowSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.grid.RowSelectionModelConfig.prototype = {
    
    singleSelect: function Ext_grid_RowSelectionModelConfig$singleSelect(value) {
        /// <summary>
        /// True to allow selection of only one row at a time (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.RowSelectionModelConfig"></returns>
        this.o['singleSelect'] = value;
        return this;
    },
    
    moveEditorOnEnter: function Ext_grid_RowSelectionModelConfig$moveEditorOnEnter(value) {
        /// <summary>
        /// False to turn off moving the editor to the next cell when the enter key is pressed
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.grid.RowSelectionModelConfig"></returns>
        this.o['moveEditorOnEnter'] = value;
        return this;
    },
    
    listeners: function Ext_grid_RowSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.RowSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_grid_RowSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.grid.RowSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_grid_RowSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.grid.RowSelectionModelEvents

Ext.grid.RowSelectionModelEvents = function Ext_grid_RowSelectionModelEvents() {
}
Ext.grid.RowSelectionModelEvents.get_selectionchange = function Ext_grid_RowSelectionModelEvents$get_selectionchange() {
    /// <summary>
    /// Fires when the selection changes
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'selectionchange';
}
Ext.grid.RowSelectionModelEvents.get_beforerowselect = function Ext_grid_RowSelectionModelEvents$get_beforerowselect() {
    /// <summary>
    /// Fires when a row is being selected, return false to cancel.
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis, {Number} rowIndex, {Boolean} keepExisting, {Record} record)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The index to be selected</description></item><item><term><b>keepExisting</b></term><description>False if other selections will be cleared</description></item><item><term><b>record</b></term><description>The record to be selected</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforerowselect';
}
Ext.grid.RowSelectionModelEvents.get_rowselect = function Ext_grid_RowSelectionModelEvents$get_rowselect() {
    /// <summary>
    /// Fires when a row is selected.
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis, {Number} rowIndex, {Ext.data.Record} r)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description>The selected index</description></item><item><term><b>r</b></term><description>The selected record</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowselect';
}
Ext.grid.RowSelectionModelEvents.get_rowdeselect = function Ext_grid_RowSelectionModelEvents$get_rowdeselect() {
    /// <summary>
    /// Fires when a row is deselected.
    /// <pre><code>
    /// USAGE: ({SelectionModel} objthis, {Number} rowIndex, {Record} record)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>rowIndex</b></term><description></description></item><item><term><b>record</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'rowdeselect';
}


Type.createNamespace('Ext.layout');

////////////////////////////////////////////////////////////////////////////////
// Ext.layout.AbsoluteLayoutConfig

Ext.layout.AbsoluteLayoutConfig = function Ext_layout_AbsoluteLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.AbsoluteLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_AbsoluteLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.AbsoluteLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_AbsoluteLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AbsoluteLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_AbsoluteLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.AbsoluteLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_AbsoluteLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.AccordionConfig

Ext.layout.AccordionConfig = function Ext_layout_AccordionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.AccordionConfig.prototype = {
    
    fill: function Ext_layout_AccordionConfig$fill(value) {
        /// <summary>
        /// True to adjust the active item's height to fill the available space in the container, false to use the item's current height, or auto height if not explicitly set (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['fill'] = value;
        return this;
    },
    
    autoWidth: function Ext_layout_AccordionConfig$autoWidth(value) {
        /// <summary>
        /// True to set each contained item's width to 'auto', false to use the item's current width (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    titleCollapse: function Ext_layout_AccordionConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expand/collapse of each contained panel by clicking anywhere on the title bar, false to allow expand/collapse only when the toggle tool button is clicked (defaults to true).  When set to false, {@link #hideCollapseTool} should be false also.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_layout_AccordionConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the contained panels' collapse/expand toggle buttons, false to display them (defaults to false). When set to true, {@link #titleCollapse} should be true also.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    collapseFirst: function Ext_layout_AccordionConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the contained panels' title bars, false to render it last (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    animate: function Ext_layout_AccordionConfig$animate(value) {
        /// <summary>
        /// True to slide the contained panels open and closed during expand/collapse using animation, false to open and close directly with no animation (defaults to false).  Note: to defer to the specific config setting of each contained panel for this property, set this to undefined at the layout level.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['animate'] = value;
        return this;
    },
    
    sequence: function Ext_layout_AccordionConfig$sequence(value) {
        /// <summary>
        /// <b>Experimental</b>. If animate is set to true, this will result in each animation running in sequence.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['sequence'] = value;
        return this;
    },
    
    activeOnTop: function Ext_layout_AccordionConfig$activeOnTop(value) {
        /// <summary>
        /// True to swap the position of each panel as it is expanded so that it becomes the first item in the container, false to keep the panels in the rendered order. <b>This is NOT compatible with "animate:true"</b> (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['activeOnTop'] = value;
        return this;
    },
    
    extraCls: function Ext_layout_AccordionConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_AccordionConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_AccordionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.AccordionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_AccordionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.AnchorLayoutConfig

Ext.layout.AnchorLayoutConfig = function Ext_layout_AnchorLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.AnchorLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_AnchorLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.AnchorLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_AnchorLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.AnchorLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_AnchorLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.AnchorLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_AnchorLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.BorderLayoutConfig

Ext.layout.BorderLayoutConfig = function Ext_layout_BorderLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.BorderLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_BorderLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.BorderLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_BorderLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_BorderLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_BorderLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.CardLayoutConfig

Ext.layout.CardLayoutConfig = function Ext_layout_CardLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.CardLayoutConfig.prototype = {
    
    deferredRender: function Ext_layout_CardLayoutConfig$deferredRender(value) {
        /// <summary>
        /// True to render each contained item at the time it becomes active, false to render all contained items as soon as the layout is rendered (defaults to false).  If there is a significant amount of content or a lot of heavy controls being rendered into panels that are not displayed by default, setting this to true might improve performance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.CardLayoutConfig"></returns>
        this.o['deferredRender'] = value;
        return this;
    },
    
    extraCls: function Ext_layout_CardLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.CardLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_CardLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.CardLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_CardLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.CardLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_CardLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.ColumnLayoutConfig

Ext.layout.ColumnLayoutConfig = function Ext_layout_ColumnLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.ColumnLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_ColumnLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.ColumnLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_ColumnLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.ColumnLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_ColumnLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.ColumnLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_ColumnLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.ContainerLayoutConfig

Ext.layout.ContainerLayoutConfig = function Ext_layout_ContainerLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.ContainerLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_ContainerLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.ContainerLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_ContainerLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.ContainerLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_ContainerLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.ContainerLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_ContainerLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.FitLayoutConfig

Ext.layout.FitLayoutConfig = function Ext_layout_FitLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.FitLayoutConfig.prototype = {
    
    extraCls: function Ext_layout_FitLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.FitLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_FitLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.FitLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_FitLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.FitLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_FitLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.FormLayoutConfig

Ext.layout.FormLayoutConfig = function Ext_layout_FormLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.FormLayoutConfig.prototype = {
    
    labelStyle: function Ext_layout_FormLayoutConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification string to add to each field label in this layout (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    elementStyle: function Ext_layout_FormLayoutConfig$elementStyle(value) {
        /// <summary>
        /// A CSS style specification string to add to each field element in this layout (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o['elementStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_layout_FormLayoutConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to a colon ':').  To turn off separators for all fields in this layout by default specify empty string '' (if the labelSeparator value is explicitly set at the field level, those will still be displayed).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    extraCls: function Ext_layout_FormLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_FormLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_FormLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.FormLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_FormLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.TableLayoutConfig

Ext.layout.TableLayoutConfig = function Ext_layout_TableLayoutConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.TableLayoutConfig.prototype = {
    
    columns: function Ext_layout_TableLayoutConfig$columns(value) {
        /// <summary>
        /// The total number of columns to create in the table for this layout.  If not specified, all panels added to this layout will be rendered into a single row using a column per panel.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.layout.TableLayoutConfig"></returns>
        this.o['columns'] = value;
        return this;
    },
    
    extraCls: function Ext_layout_TableLayoutConfig$extraCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to the container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.TableLayoutConfig"></returns>
        this.o['extraCls'] = value;
        return this;
    },
    
    renderHidden: function Ext_layout_TableLayoutConfig$renderHidden(value) {
        /// <summary>
        /// True to hide each contained item on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.TableLayoutConfig"></returns>
        this.o['renderHidden'] = value;
        return this;
    },
    
    custom: function Ext_layout_TableLayoutConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.TableLayoutConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_TableLayoutConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.layout.BorderLayout');

////////////////////////////////////////////////////////////////////////////////
// Ext.layout.BorderLayout.RegionConfig

Ext.layout.BorderLayout.RegionConfig = function Ext_layout_BorderLayout_RegionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.BorderLayout.RegionConfig.prototype = {
    
    animFloat: function Ext_layout_BorderLayout_RegionConfig$animFloat(value) {
        /// <summary>
        /// When a collapsed region's bar is clicked, the region's panel will be displayed as a floated panel that will close again once the user mouses out of that panel (or clicks out if autoHide = false).  Setting animFloat to false will prevent the open and close of these floated panels from being animated (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['animFloat'] = value;
        return this;
    },
    
    autoHide: function Ext_layout_BorderLayout_RegionConfig$autoHide(value) {
        /// <summary>
        /// When a collapsed region's bar is clicked, the region's panel will be displayed as a floated panel.  If autoHide is true, the panel will automatically hide after the user mouses out of the panel.  If autoHide is false, the panel will continue to display until the user clicks outside of the panel (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['autoHide'] = value;
        return this;
    },
    
    collapsed: function Ext_layout_BorderLayout_RegionConfig$collapsed(value) {
        /// <summary>
        /// By default, collapsible regions will be visible when rendered. Set the collapsed config to true to render the region as collapsed.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseMode: function Ext_layout_BorderLayout_RegionConfig$collapseMode(value) {
        /// <summary>
        /// By default, collapsible regions are collapsed by clicking the expand/collapse tool button that renders into the region's title bar.  Optionally, when collapseMode is set to 'mini' the region's split bar will also display a small collapse button in the center of the bar.  In 'mini' mode the region will collapse to a thinner bar than in normal mode.  By default collapseMode is undefined, and the only two supported values are undefined and 'mini'.  Note that if a collapsible region does not have a title bar, then collapseMode must be set to 'mini' in order for the region to be collapsible by the user as the tool button will not be rendered.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['collapseMode'] = value;
        return this;
    },
    
    margins: function Ext_layout_BorderLayout_RegionConfig$margins(value) {
        /// <summary>
        /// An object containing margins to apply to the region in the format {left: (left margin), top: (top margin), right: (right margin), bottom: (bottom margin)}
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['margins'] = value;
        return this;
    },
    
    cmargins: function Ext_layout_BorderLayout_RegionConfig$cmargins(value) {
        /// <summary>
        /// An object containing margins to apply to the region's collapsed element in the format {left: (left margin), top: (top margin), right: (right margin), bottom: (bottom margin)}
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['cmargins'] = value;
        return this;
    },
    
    collapsible: function Ext_layout_BorderLayout_RegionConfig$collapsible(value) {
        /// <summary>
        /// True to allow the user to collapse this region (defaults to false).  If true, an expand/collapse tool button will automatically be rendered into the title bar of the region, otherwise the button will not be shown. Note that a title bar is required to display the toggle button -- if no region title is specified, the region will only be collapsible if {@link #collapseMode} is set to 'mini'.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    split: function Ext_layout_BorderLayout_RegionConfig$split(value) {
        /// <summary>
        /// True to display a {@link Ext.SplitBar} between this region and its neighbor, allowing the user to resize the regions dynamically (defaults to false).  When split = true, it is common to specify a {@link #minSize} and {@link #maxSize} for the region.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['split'] = value;
        return this;
    },
    
    floatable: function Ext_layout_BorderLayout_RegionConfig$floatable(value) {
        /// <summary>
        /// True to allow clicking a collapsed region's bar to display the region's panel floated above the layout, false to force the user to fully expand a collapsed region by clicking the expand button to see it again (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['floatable'] = value;
        return this;
    },
    
    minWidth: function Ext_layout_BorderLayout_RegionConfig$minWidth(value) {
        /// <summary>
        /// The minimum allowable width in pixels for this region (defaults to 50)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    minHeight: function Ext_layout_BorderLayout_RegionConfig$minHeight(value) {
        /// <summary>
        /// The minimum allowable height in pixels for this region (defaults to 50)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    custom: function Ext_layout_BorderLayout_RegionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.RegionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_BorderLayout_RegionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.layout.BorderLayout.SplitRegionConfig

Ext.layout.BorderLayout.SplitRegionConfig = function Ext_layout_BorderLayout_SplitRegionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.layout.BorderLayout.SplitRegionConfig.prototype = {
    
    splitTip: function Ext_layout_BorderLayout_SplitRegionConfig$splitTip(value) {
        /// <summary>
        /// The tooltip to display when the user hovers over a non-collapsible region's split bar (defaults to "Drag to resize.").  Only applies if {@link #useSplitTips} = true.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['splitTip'] = value;
        return this;
    },
    
    collapsibleSplitTip: function Ext_layout_BorderLayout_SplitRegionConfig$collapsibleSplitTip(value) {
        /// <summary>
        /// The tooltip to display when the user hovers over a collapsible region's split bar (defaults to "Drag to resize. Double click to hide.").  Only applies if {@link #useSplitTips} = true.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['collapsibleSplitTip'] = value;
        return this;
    },
    
    useSplitTips: function Ext_layout_BorderLayout_SplitRegionConfig$useSplitTips(value) {
        /// <summary>
        /// True to display a tooltip when the user hovers over a region's split bar (defaults to false).  The tooltip text will be the value of either {@link #splitTip} or {@link #collapsibleSplitTip} as appropriate.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['useSplitTips'] = value;
        return this;
    },
    
    animFloat: function Ext_layout_BorderLayout_SplitRegionConfig$animFloat(value) {
        /// <summary>
        /// When a collapsed region's bar is clicked, the region's panel will be displayed as a floated panel that will close again once the user mouses out of that panel (or clicks out if autoHide = false).  Setting animFloat to false will prevent the open and close of these floated panels from being animated (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['animFloat'] = value;
        return this;
    },
    
    autoHide: function Ext_layout_BorderLayout_SplitRegionConfig$autoHide(value) {
        /// <summary>
        /// When a collapsed region's bar is clicked, the region's panel will be displayed as a floated panel.  If autoHide is true, the panel will automatically hide after the user mouses out of the panel.  If autoHide is false, the panel will continue to display until the user clicks outside of the panel (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['autoHide'] = value;
        return this;
    },
    
    collapsed: function Ext_layout_BorderLayout_SplitRegionConfig$collapsed(value) {
        /// <summary>
        /// By default, collapsible regions will be visible when rendered. Set the collapsed config to true to render the region as collapsed.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseMode: function Ext_layout_BorderLayout_SplitRegionConfig$collapseMode(value) {
        /// <summary>
        /// By default, collapsible regions are collapsed by clicking the expand/collapse tool button that renders into the region's title bar.  Optionally, when collapseMode is set to 'mini' the region's split bar will also display a small collapse button in the center of the bar.  In 'mini' mode the region will collapse to a thinner bar than in normal mode.  By default collapseMode is undefined, and the only two supported values are undefined and 'mini'.  Note that if a collapsible region does not have a title bar, then collapseMode must be set to 'mini' in order for the region to be collapsible by the user as the tool button will not be rendered.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['collapseMode'] = value;
        return this;
    },
    
    margins: function Ext_layout_BorderLayout_SplitRegionConfig$margins(value) {
        /// <summary>
        /// An object containing margins to apply to the region in the format {left: (left margin), top: (top margin), right: (right margin), bottom: (bottom margin)}
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['margins'] = value;
        return this;
    },
    
    cmargins: function Ext_layout_BorderLayout_SplitRegionConfig$cmargins(value) {
        /// <summary>
        /// An object containing margins to apply to the region's collapsed element in the format {left: (left margin), top: (top margin), right: (right margin), bottom: (bottom margin)}
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['cmargins'] = value;
        return this;
    },
    
    collapsible: function Ext_layout_BorderLayout_SplitRegionConfig$collapsible(value) {
        /// <summary>
        /// True to allow the user to collapse this region (defaults to false).  If true, an expand/collapse tool button will automatically be rendered into the title bar of the region, otherwise the button will not be shown. Note that a title bar is required to display the toggle button -- if no region title is specified, the region will only be collapsible if {@link #collapseMode} is set to 'mini'.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    split: function Ext_layout_BorderLayout_SplitRegionConfig$split(value) {
        /// <summary>
        /// True to display a {@link Ext.SplitBar} between this region and its neighbor, allowing the user to resize the regions dynamically (defaults to false).  When split = true, it is common to specify a {@link #minSize} and {@link #maxSize} for the region.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['split'] = value;
        return this;
    },
    
    floatable: function Ext_layout_BorderLayout_SplitRegionConfig$floatable(value) {
        /// <summary>
        /// True to allow clicking a collapsed region's bar to display the region's panel floated above the layout, false to force the user to fully expand a collapsed region by clicking the expand button to see it again (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['floatable'] = value;
        return this;
    },
    
    minWidth: function Ext_layout_BorderLayout_SplitRegionConfig$minWidth(value) {
        /// <summary>
        /// The minimum allowable width in pixels for this region (defaults to 50)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    minHeight: function Ext_layout_BorderLayout_SplitRegionConfig$minHeight(value) {
        /// <summary>
        /// The minimum allowable height in pixels for this region (defaults to 50)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    custom: function Ext_layout_BorderLayout_SplitRegionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.layout.BorderLayout.SplitRegionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_layout_BorderLayout_SplitRegionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.menu');

////////////////////////////////////////////////////////////////////////////////
// Ext.menu.AdapterConfig

Ext.menu.AdapterConfig = function Ext_menu_AdapterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.AdapterConfig.prototype = {
    
    handler: function Ext_menu_AdapterConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_AdapterConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_AdapterConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_AdapterConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_AdapterConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_AdapterConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_AdapterConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_AdapterConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_AdapterConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_AdapterConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_AdapterConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_AdapterConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_AdapterConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_AdapterConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_AdapterConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_AdapterConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_AdapterConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_AdapterConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_AdapterConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_AdapterConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_AdapterConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_AdapterConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_AdapterConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_AdapterConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_AdapterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.AdapterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_AdapterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.BaseItemConfig

Ext.menu.BaseItemConfig = function Ext_menu_BaseItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.BaseItemConfig.prototype = {
    
    handler: function Ext_menu_BaseItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_BaseItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_BaseItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_BaseItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_BaseItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_BaseItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_BaseItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_BaseItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_BaseItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_BaseItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_BaseItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_BaseItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_BaseItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_BaseItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_BaseItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_BaseItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_BaseItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_BaseItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_BaseItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_BaseItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_BaseItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_BaseItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_BaseItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_BaseItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_BaseItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.BaseItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_BaseItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.BaseItemEvents

Ext.menu.BaseItemEvents = function Ext_menu_BaseItemEvents() {
}
Ext.menu.BaseItemEvents.get_click = function Ext_menu_BaseItemEvents$get_click() {
    /// <summary>
    /// Fires when this item is clicked
    /// <pre><code>
    /// USAGE: ({Ext.menu.BaseItem} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.menu.BaseItemEvents.get_activate = function Ext_menu_BaseItemEvents$get_activate() {
    /// <summary>
    /// Fires when this item is activated
    /// <pre><code>
    /// USAGE: ({Ext.menu.BaseItem} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'activate';
}
Ext.menu.BaseItemEvents.get_deactivate = function Ext_menu_BaseItemEvents$get_deactivate() {
    /// <summary>
    /// Fires when this item is deactivated
    /// <pre><code>
    /// USAGE: ({Ext.menu.BaseItem} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'deactivate';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.CheckItemConfig

Ext.menu.CheckItemConfig = function Ext_menu_CheckItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.CheckItemConfig.prototype = {
    
    group: function Ext_menu_CheckItemConfig$group(value) {
        /// <summary>
        /// All check items with the same group name will automatically be grouped into a single-select radio button group (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['group'] = value;
        return this;
    },
    
    itemCls: function Ext_menu_CheckItemConfig$itemCls(value) {
        /// <summary>
        /// The default CSS class to use for check items (defaults to "x-menu-item x-menu-check-item")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    groupClass: function Ext_menu_CheckItemConfig$groupClass(value) {
        /// <summary>
        /// The default CSS class to use for radio group check items (defaults to "x-menu-group-item")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['groupClass'] = value;
        return this;
    },
    
    checked_: function Ext_menu_CheckItemConfig$checked_(value) {
        /// <summary>
        /// True to initialize this checkbox as checked (defaults to false).  Note that if this checkbox is part of a radio group (group = true) only the last item in the group that is initialized with checked = true will be rendered as checked.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['checked'] = value;
        return this;
    },
    
    menu: function Ext_menu_CheckItemConfig$menu(value) {
        /// <summary>
        /// Either an instance of {@link Ext.menu.Menu} or the config object for an {@link Ext.menu.Menu} which acts as the submenu when this item is activated.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    icon: function Ext_menu_CheckItemConfig$icon(value) {
        /// <summary>
        /// The path to an icon to display in this item (defaults to Ext.BLANK_IMAGE_URL).  If icon is specified {@link #iconCls} should not be.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    iconCls: function Ext_menu_CheckItemConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that specifies a background image that will be used as the icon for this item (defaults to '').  If iconCls is specified {@link #icon} should not be.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    text: function Ext_menu_CheckItemConfig$text(value) {
        /// <summary>
        /// The text to display in this item (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    href: function Ext_menu_CheckItemConfig$href(value) {
        /// <summary>
        /// The href attribute to use for the underlying anchor link (defaults to '#').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['href'] = value;
        return this;
    },
    
    hrefTarget: function Ext_menu_CheckItemConfig$hrefTarget(value) {
        /// <summary>
        /// The target attribute to use for the underlying anchor link (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['hrefTarget'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_CheckItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    showDelay: function Ext_menu_CheckItemConfig$showDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before showing this item (defaults to 200)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['showDelay'] = value;
        return this;
    },
    
    handler: function Ext_menu_CheckItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_CheckItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_CheckItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_CheckItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_CheckItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_CheckItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_CheckItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_CheckItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_CheckItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_CheckItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_CheckItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_CheckItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_CheckItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_CheckItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_CheckItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_CheckItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_CheckItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_CheckItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_CheckItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_CheckItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_CheckItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_CheckItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_CheckItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_CheckItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.CheckItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_CheckItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.CheckItemEvents

Ext.menu.CheckItemEvents = function Ext_menu_CheckItemEvents() {
}
Ext.menu.CheckItemEvents.get_beforecheckchange = function Ext_menu_CheckItemEvents$get_beforecheckchange() {
    /// <summary>
    /// Fires before the checked value is set, providing an opportunity to cancel if needed
    /// <pre><code>
    /// USAGE: ({Ext.menu.CheckItem} objthis, {Boolean} chckd)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>chckd</b></term><description>The new checked value that will be set</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecheckchange';
}
Ext.menu.CheckItemEvents.get_checkchange = function Ext_menu_CheckItemEvents$get_checkchange() {
    /// <summary>
    /// Fires after the checked value has been set
    /// <pre><code>
    /// USAGE: ({Ext.menu.CheckItem} objthis, {Boolean} chckd)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>chckd</b></term><description>The checked value that was set</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'checkchange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.ColorItemConfig

Ext.menu.ColorItemConfig = function Ext_menu_ColorItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.ColorItemConfig.prototype = {
    
    handler: function Ext_menu_ColorItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_ColorItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_ColorItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_ColorItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_ColorItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_ColorItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_ColorItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_ColorItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_ColorItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_ColorItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_ColorItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_ColorItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_ColorItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_ColorItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_ColorItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_ColorItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_ColorItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_ColorItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_ColorItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_ColorItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_ColorItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_ColorItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_ColorItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_ColorItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_ColorItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_ColorItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.ColorMenuConfig

Ext.menu.ColorMenuConfig = function Ext_menu_ColorMenuConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.ColorMenuConfig.prototype = {
    
    defaults: function Ext_menu_ColorMenuConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all items added to this container either via the {@link #items} config or via the {@link #add} method.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the menu.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    items: function Ext_menu_ColorMenuConfig$items(value) {
        /// <summary>
        /// An array of items to be added to this menu.  See {@link #add} for a list of valid item types.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    minWidth: function Ext_menu_ColorMenuConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the menu in pixels (defaults to 120)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    shadow: function Ext_menu_ColorMenuConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    subMenuAlign: function Ext_menu_ColorMenuConfig$subMenuAlign(value) {
        /// <summary>
        /// The {@link Ext.Element#alignTo} anchor position value to use for submenus of this menu (defaults to "tl-tr?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['subMenuAlign'] = value;
        return this;
    },
    
    defaultAlign: function Ext_menu_ColorMenuConfig$defaultAlign(value) {
        /// <summary>
        /// The default {@link Ext.Element#alignTo} anchor position value for this menu relative to its element of origin (defaults to "tl-bl?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    allowOtherMenus: function Ext_menu_ColorMenuConfig$allowOtherMenus(value) {
        /// <summary>
        /// True to allow multiple menus to be displayed at the same time (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['allowOtherMenus'] = value;
        return this;
    },
    
    listeners: function Ext_menu_ColorMenuConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_ColorMenuConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ColorMenuConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_ColorMenuConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.ColorMenuEvents

Ext.menu.ColorMenuEvents = function Ext_menu_ColorMenuEvents() {
}
Ext.menu.ColorMenuEvents.get_select = function Ext_menu_ColorMenuEvents$get_select() {
    /// <summary>
    /// <pre><code>
    /// USAGE: ({ColorPalette} palette, {String} color)
    /// </code></pre><list type="bullet"><item><term><b>palette</b></term><description></description></item><item><term><b>color</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'select';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.DateItemConfig

Ext.menu.DateItemConfig = function Ext_menu_DateItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.DateItemConfig.prototype = {
    
    handler: function Ext_menu_DateItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_DateItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_DateItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_DateItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_DateItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_DateItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_DateItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_DateItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_DateItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_DateItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_DateItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_DateItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_DateItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_DateItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_DateItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_DateItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_DateItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_DateItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_DateItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_DateItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_DateItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_DateItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_DateItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_DateItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_DateItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_DateItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.DateMenuConfig

Ext.menu.DateMenuConfig = function Ext_menu_DateMenuConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.DateMenuConfig.prototype = {
    
    defaults: function Ext_menu_DateMenuConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all items added to this container either via the {@link #items} config or via the {@link #add} method.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the menu.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    items: function Ext_menu_DateMenuConfig$items(value) {
        /// <summary>
        /// An array of items to be added to this menu.  See {@link #add} for a list of valid item types.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    minWidth: function Ext_menu_DateMenuConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the menu in pixels (defaults to 120)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    shadow: function Ext_menu_DateMenuConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    subMenuAlign: function Ext_menu_DateMenuConfig$subMenuAlign(value) {
        /// <summary>
        /// The {@link Ext.Element#alignTo} anchor position value to use for submenus of this menu (defaults to "tl-tr?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['subMenuAlign'] = value;
        return this;
    },
    
    defaultAlign: function Ext_menu_DateMenuConfig$defaultAlign(value) {
        /// <summary>
        /// The default {@link Ext.Element#alignTo} anchor position value for this menu relative to its element of origin (defaults to "tl-bl?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    allowOtherMenus: function Ext_menu_DateMenuConfig$allowOtherMenus(value) {
        /// <summary>
        /// True to allow multiple menus to be displayed at the same time (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['allowOtherMenus'] = value;
        return this;
    },
    
    listeners: function Ext_menu_DateMenuConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_DateMenuConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.DateMenuConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_DateMenuConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.DateMenuEvents

Ext.menu.DateMenuEvents = function Ext_menu_DateMenuEvents() {
}
Ext.menu.DateMenuEvents.get_select = function Ext_menu_DateMenuEvents$get_select() {
    /// <summary>
    /// <pre><code>
    /// USAGE: ({DatePicker} picker, {Date} date)
    /// </code></pre><list type="bullet"><item><term><b>picker</b></term><description></description></item><item><term><b>date</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'select';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.ItemConfig

Ext.menu.ItemConfig = function Ext_menu_ItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.ItemConfig.prototype = {
    
    menu: function Ext_menu_ItemConfig$menu(value) {
        /// <summary>
        /// Either an instance of {@link Ext.menu.Menu} or the config object for an {@link Ext.menu.Menu} which acts as the submenu when this item is activated.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    icon: function Ext_menu_ItemConfig$icon(value) {
        /// <summary>
        /// The path to an icon to display in this item (defaults to Ext.BLANK_IMAGE_URL).  If icon is specified {@link #iconCls} should not be.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    iconCls: function Ext_menu_ItemConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that specifies a background image that will be used as the icon for this item (defaults to '').  If iconCls is specified {@link #icon} should not be.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    text: function Ext_menu_ItemConfig$text(value) {
        /// <summary>
        /// The text to display in this item (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    href: function Ext_menu_ItemConfig$href(value) {
        /// <summary>
        /// The href attribute to use for the underlying anchor link (defaults to '#').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['href'] = value;
        return this;
    },
    
    hrefTarget: function Ext_menu_ItemConfig$hrefTarget(value) {
        /// <summary>
        /// The target attribute to use for the underlying anchor link (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['hrefTarget'] = value;
        return this;
    },
    
    itemCls: function Ext_menu_ItemConfig$itemCls(value) {
        /// <summary>
        /// The default CSS class to use for menu items (defaults to 'x-menu-item')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_ItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    showDelay: function Ext_menu_ItemConfig$showDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before showing this item (defaults to 200)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['showDelay'] = value;
        return this;
    },
    
    handler: function Ext_menu_ItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_ItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_ItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_ItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_ItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_ItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_ItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_ItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_ItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_ItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_ItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_ItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_ItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_ItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_ItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_ItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_ItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_ItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_ItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_ItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_ItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_ItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_ItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_ItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.ItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_ItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.MenuConfig

Ext.menu.MenuConfig = function Ext_menu_MenuConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.MenuConfig.prototype = {
    
    defaults: function Ext_menu_MenuConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all items added to this container either via the {@link #items} config or via the {@link #add} method.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the menu.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    items: function Ext_menu_MenuConfig$items(value) {
        /// <summary>
        /// An array of items to be added to this menu.  See {@link #add} for a list of valid item types.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    minWidth: function Ext_menu_MenuConfig$minWidth(value) {
        /// <summary>
        /// The minimum width of the menu in pixels (defaults to 120)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    shadow: function Ext_menu_MenuConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "sides")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    subMenuAlign: function Ext_menu_MenuConfig$subMenuAlign(value) {
        /// <summary>
        /// The {@link Ext.Element#alignTo} anchor position value to use for submenus of this menu (defaults to "tl-tr?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['subMenuAlign'] = value;
        return this;
    },
    
    defaultAlign: function Ext_menu_MenuConfig$defaultAlign(value) {
        /// <summary>
        /// The default {@link Ext.Element#alignTo} anchor position value for this menu relative to its element of origin (defaults to "tl-bl?")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['defaultAlign'] = value;
        return this;
    },
    
    allowOtherMenus: function Ext_menu_MenuConfig$allowOtherMenus(value) {
        /// <summary>
        /// True to allow multiple menus to be displayed at the same time (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['allowOtherMenus'] = value;
        return this;
    },
    
    listeners: function Ext_menu_MenuConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_MenuConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_MenuConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.MenuEvents

Ext.menu.MenuEvents = function Ext_menu_MenuEvents() {
}
Ext.menu.MenuEvents.get_beforeshow = function Ext_menu_MenuEvents$get_beforeshow() {
    /// <summary>
    /// Fires before this menu is displayed
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeshow';
}
Ext.menu.MenuEvents.get_beforehide = function Ext_menu_MenuEvents$get_beforehide() {
    /// <summary>
    /// Fires before this menu is hidden
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforehide';
}
Ext.menu.MenuEvents.get_show = function Ext_menu_MenuEvents$get_show() {
    /// <summary>
    /// Fires after this menu is displayed
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'show';
}
Ext.menu.MenuEvents.get_hide = function Ext_menu_MenuEvents$get_hide() {
    /// <summary>
    /// Fires after this menu is hidden
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'hide';
}
Ext.menu.MenuEvents.get_click = function Ext_menu_MenuEvents$get_click() {
    /// <summary>
    /// Fires when this menu is clicked (or when the enter key is pressed while it is active)
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis, {Ext.menu.Item} menuItem, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>menuItem</b></term><description>The menu item that was clicked</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.menu.MenuEvents.get_mouseover = function Ext_menu_MenuEvents$get_mouseover() {
    /// <summary>
    /// Fires when the mouse is hovering over this menu
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis, {Ext.EventObject} e, {Ext.menu.Item} menuItem)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description></description></item><item><term><b>menuItem</b></term><description>The menu item that was clicked</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseover';
}
Ext.menu.MenuEvents.get_mouseout = function Ext_menu_MenuEvents$get_mouseout() {
    /// <summary>
    /// Fires when the mouse exits this menu
    /// <pre><code>
    /// USAGE: ({Ext.menu.Menu} objthis, {Ext.EventObject} e, {Ext.menu.Item} menuItem)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>e</b></term><description></description></item><item><term><b>menuItem</b></term><description>The menu item that was clicked</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseout';
}
Ext.menu.MenuEvents.get_itemclick = function Ext_menu_MenuEvents$get_itemclick() {
    /// <summary>
    /// Fires when a menu item contained in this menu is clicked
    /// <pre><code>
    /// USAGE: ({Ext.menu.BaseItem} baseItem, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>baseItem</b></term><description>The BaseItem that was clicked</description></item><item><term><b>e</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'itemclick';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.MenuMgrConfig

Ext.menu.MenuMgrConfig = function Ext_menu_MenuMgrConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.MenuMgrConfig.prototype = {
    
    custom: function Ext_menu_MenuMgrConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.MenuMgrConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_MenuMgrConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.SeparatorConfig

Ext.menu.SeparatorConfig = function Ext_menu_SeparatorConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.SeparatorConfig.prototype = {
    
    itemCls: function Ext_menu_SeparatorConfig$itemCls(value) {
        /// <summary>
        /// The default CSS class to use for separators (defaults to "x-menu-sep")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_SeparatorConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    handler: function Ext_menu_SeparatorConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_SeparatorConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_SeparatorConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_SeparatorConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_SeparatorConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_SeparatorConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_SeparatorConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_SeparatorConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_SeparatorConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_SeparatorConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_SeparatorConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_SeparatorConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_SeparatorConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_SeparatorConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_SeparatorConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_SeparatorConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_SeparatorConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_SeparatorConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_SeparatorConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_SeparatorConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_SeparatorConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_SeparatorConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_SeparatorConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_SeparatorConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.SeparatorConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_SeparatorConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.menu.TextItemConfig

Ext.menu.TextItemConfig = function Ext_menu_TextItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.menu.TextItemConfig.prototype = {
    
    text: function Ext_menu_TextItemConfig$text(value) {
        /// <summary>
        /// The text to display for this item (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    hideOnClick: function Ext_menu_TextItemConfig$hideOnClick(value) {
        /// <summary>
        /// True to hide the containing menu after this item is clicked (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['hideOnClick'] = value;
        return this;
    },
    
    itemCls: function Ext_menu_TextItemConfig$itemCls(value) {
        /// <summary>
        /// The default CSS class to use for text items (defaults to "x-menu-text")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    handler: function Ext_menu_TextItemConfig$handler(value) {
        /// <summary>
        /// A function that will handle the click event of this menu item (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_menu_TextItemConfig$scope(value) {
        /// <summary>
        /// The scope in which the handler function will be called.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    canActivate: function Ext_menu_TextItemConfig$canActivate(value) {
        /// <summary>
        /// True if this item can be visually activated (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['canActivate'] = value;
        return this;
    },
    
    activeClass: function Ext_menu_TextItemConfig$activeClass(value) {
        /// <summary>
        /// The CSS class to use when the item becomes activated (defaults to "x-menu-item-active")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['activeClass'] = value;
        return this;
    },
    
    hideDelay: function Ext_menu_TextItemConfig$hideDelay(value) {
        /// <summary>
        /// Length of time in milliseconds to wait before hiding after a click (defaults to 100)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['hideDelay'] = value;
        return this;
    },
    
    xtype: function Ext_menu_TextItemConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_menu_TextItemConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_menu_TextItemConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_menu_TextItemConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_menu_TextItemConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_menu_TextItemConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_menu_TextItemConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_menu_TextItemConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_menu_TextItemConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_menu_TextItemConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_menu_TextItemConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_menu_TextItemConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_menu_TextItemConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_menu_TextItemConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_menu_TextItemConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_menu_TextItemConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_menu_TextItemConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_menu_TextItemConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_menu_TextItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.menu.TextItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_menu_TextItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.SplitBar');

////////////////////////////////////////////////////////////////////////////////
// Ext.SplitBar.AbsoluteLayoutAdapterConfig

Ext.SplitBar.AbsoluteLayoutAdapterConfig = function Ext_SplitBar_AbsoluteLayoutAdapterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.SplitBar.AbsoluteLayoutAdapterConfig.prototype = {
    
    custom: function Ext_SplitBar_AbsoluteLayoutAdapterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitBar.AbsoluteLayoutAdapterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_SplitBar_AbsoluteLayoutAdapterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.SplitBar.BasicLayoutAdapterConfig

Ext.SplitBar.BasicLayoutAdapterConfig = function Ext_SplitBar_BasicLayoutAdapterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.SplitBar.BasicLayoutAdapterConfig.prototype = {
    
    custom: function Ext_SplitBar_BasicLayoutAdapterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.SplitBar.BasicLayoutAdapterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_SplitBar_BasicLayoutAdapterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.state');

////////////////////////////////////////////////////////////////////////////////
// Ext.state.CookieProviderConfig

Ext.state.CookieProviderConfig = function Ext_state_CookieProviderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.state.CookieProviderConfig.prototype = {
    
    path: function Ext_state_CookieProviderConfig$path(value) {
        /// <summary>
        /// The path for which the cookie is active (defaults to root '/' which makes it active for all pages in the site)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.state.CookieProviderConfig"></returns>
        this.o['path'] = value;
        return this;
    },
    
    expires: function Ext_state_CookieProviderConfig$expires(value) {
        /// <summary>
        /// The cookie expiration date (defaults to 7 days from now)
        /// </summary>
        /// <param name="value" type="Date">
        /// </param>
        /// <returns type="Ext.state.CookieProviderConfig"></returns>
        this.o['expires'] = value;
        return this;
    },
    
    domain: function Ext_state_CookieProviderConfig$domain(value) {
        /// <summary>
        /// The domain to save the cookie for.  Note that you cannot specify a different domain than
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.state.CookieProviderConfig"></returns>
        this.o['domain'] = value;
        return this;
    },
    
    secure: function Ext_state_CookieProviderConfig$secure(value) {
        /// <summary>
        /// True if the site is using SSL (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.state.CookieProviderConfig"></returns>
        this.o['secure'] = value;
        return this;
    },
    
    custom: function Ext_state_CookieProviderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.state.CookieProviderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_state_CookieProviderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.state.ManagerConfig

Ext.state.ManagerConfig = function Ext_state_ManagerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.state.ManagerConfig.prototype = {
    
    custom: function Ext_state_ManagerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.state.ManagerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_state_ManagerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.state.ProviderConfig

Ext.state.ProviderConfig = function Ext_state_ProviderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.state.ProviderConfig.prototype = {
    
    custom: function Ext_state_ProviderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.state.ProviderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_state_ProviderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.state.ProviderEvents

Ext.state.ProviderEvents = function Ext_state_ProviderEvents() {
}
Ext.state.ProviderEvents.get_statechange = function Ext_state_ProviderEvents$get_statechange() {
    /// <summary>
    /// Fires when a state change occurs.
    /// <pre><code>
    /// USAGE: ({Provider} objthis, {String} key, {String} value)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This state provider</description></item><item><term><b>key</b></term><description>The state key which was changed</description></item><item><term><b>value</b></term><description>The encoded value for the state</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'statechange';
}


Type.createNamespace('Ext.Toolbar');

////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.ButtonConfig

Ext.Toolbar.ButtonConfig = function Ext_Toolbar_ButtonConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.ButtonConfig.prototype = {
    
    text: function Ext_Toolbar_ButtonConfig$text(value) {
        /// <summary>
        /// The button text
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    icon: function Ext_Toolbar_ButtonConfig$icon(value) {
        /// <summary>
        /// The path to an image to display in the button (the image will be set as the background-image
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    handler: function Ext_Toolbar_ButtonConfig$handler(value) {
        /// <summary>
        /// A function called when the button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_Toolbar_ButtonConfig$scope(value) {
        /// <summary>
        /// The scope of the handler
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    minWidth: function Ext_Toolbar_ButtonConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for this button (used to give a set of buttons a common width)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    tooltip: function Ext_Toolbar_ButtonConfig$tooltip(value) {
        /// <summary>
        /// {String/Object} The tooltip for the button - can be a string or QuickTips config object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    hidden: function Ext_Toolbar_ButtonConfig$hidden(value) {
        /// <summary>
        /// True to start hidden (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    disabled: function Ext_Toolbar_ButtonConfig$disabled(value) {
        /// <summary>
        /// True to start disabled (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    pressed: function Ext_Toolbar_ButtonConfig$pressed(value) {
        /// <summary>
        /// True to start pressed (only if enableToggle = true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['pressed'] = value;
        return this;
    },
    
    toggleGroup: function Ext_Toolbar_ButtonConfig$toggleGroup(value) {
        /// <summary>
        /// The group this toggle button is a member of (only 1 per group can be pressed, only
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['toggleGroup'] = value;
        return this;
    },
    
    repeat: function Ext_Toolbar_ButtonConfig$repeat(value) {
        /// <summary>
        /// {Boolean/Object} True to repeat fire the click event while the mouse is down. This can also be
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['repeat'] = value;
        return this;
    },
    
    tabIndex: function Ext_Toolbar_ButtonConfig$tabIndex(value) {
        /// <summary>
        /// Set a DOM tabIndex for this button (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    allowDepress: function Ext_Toolbar_ButtonConfig$allowDepress(value) {
        /// <summary>
        /// True to allow a pressed Button to be depressed (defaults to false). Only valid when {@link #enableToggle} is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['allowDepress'] = value;
        return this;
    },
    
    enableToggle: function Ext_Toolbar_ButtonConfig$enableToggle(value) {
        /// <summary>
        /// True to enable pressed/not pressed toggling (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['enableToggle'] = value;
        return this;
    },
    
    toggleHandler: function Ext_Toolbar_ButtonConfig$toggleHandler(value) {
        /// <summary>
        /// Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:<ul class="mdetail-params"><li><b>button</b> : Ext.Button<div class="sub-desc">this Button object</div></li><li><b>state</b> : Boolean<div class="sub-desc">The next state if the Button, true means pressed.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['toggleHandler'] = value;
        return this;
    },
    
    menu: function Ext_Toolbar_ButtonConfig$menu(value) {
        /// <summary>
        /// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    menuAlign: function Ext_Toolbar_ButtonConfig$menuAlign(value) {
        /// <summary>
        /// The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['menuAlign'] = value;
        return this;
    },
    
    iconCls: function Ext_Toolbar_ButtonConfig$iconCls(value) {
        /// <summary>
        /// A css class which sets a background image to be used as the icon for this button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    type: function Ext_Toolbar_ButtonConfig$type(value) {
        /// <summary>
        /// submit, reset or button - defaults to 'button'
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['type'] = value;
        return this;
    },
    
    clickEvent: function Ext_Toolbar_ButtonConfig$clickEvent(value) {
        /// <summary>
        /// The type of event to map to the button's event handler (defaults to 'click')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['clickEvent'] = value;
        return this;
    },
    
    handleMouseEvents: function Ext_Toolbar_ButtonConfig$handleMouseEvents(value) {
        /// <summary>
        /// False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['handleMouseEvents'] = value;
        return this;
    },
    
    tooltipType: function Ext_Toolbar_ButtonConfig$tooltipType(value) {
        /// <summary>
        /// The type of tooltip to use. Either "qtip" (default) for QuickTips or "title" for title attribute.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['tooltipType'] = value;
        return this;
    },
    
    template: function Ext_Toolbar_ButtonConfig$template(value) {
        /// <summary>
        /// (Optional) An {@link Ext.Template} with which to create the Button's main element. This Template must contain numeric substitution parameter 0 if it is to display the text property. Changing the template could require code modifications if required elements (e.g. a button) aren't present.
        /// </summary>
        /// <param name="value" type="Ext.Template">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['template'] = value;
        return this;
    },
    
    cls: function Ext_Toolbar_ButtonConfig$cls(value) {
        /// <summary>
        /// A CSS class string to apply to the button's main element.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    xtype: function Ext_Toolbar_ButtonConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_Toolbar_ButtonConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_Toolbar_ButtonConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_Toolbar_ButtonConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_Toolbar_ButtonConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_Toolbar_ButtonConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_Toolbar_ButtonConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_Toolbar_ButtonConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_Toolbar_ButtonConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_Toolbar_ButtonConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_Toolbar_ButtonConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_Toolbar_ButtonConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_Toolbar_ButtonConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_Toolbar_ButtonConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_Toolbar_ButtonConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_Toolbar_ButtonConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_Toolbar_ButtonConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_Toolbar_ButtonConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ButtonConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_ButtonConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.FillConfig

Ext.Toolbar.FillConfig = function Ext_Toolbar_FillConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.FillConfig.prototype = {
    
    custom: function Ext_Toolbar_FillConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.FillConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_FillConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.ItemConfig

Ext.Toolbar.ItemConfig = function Ext_Toolbar_ItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.ItemConfig.prototype = {
    
    custom: function Ext_Toolbar_ItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.ItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_ItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.SeparatorConfig

Ext.Toolbar.SeparatorConfig = function Ext_Toolbar_SeparatorConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.SeparatorConfig.prototype = {
    
    custom: function Ext_Toolbar_SeparatorConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SeparatorConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_SeparatorConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.SpacerConfig

Ext.Toolbar.SpacerConfig = function Ext_Toolbar_SpacerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.SpacerConfig.prototype = {
    
    custom: function Ext_Toolbar_SpacerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SpacerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_SpacerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.SplitButtonConfig

Ext.Toolbar.SplitButtonConfig = function Ext_Toolbar_SplitButtonConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.SplitButtonConfig.prototype = {
    
    arrowHandler: function Ext_Toolbar_SplitButtonConfig$arrowHandler(value) {
        /// <summary>
        /// A function called when the arrow button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['arrowHandler'] = value;
        return this;
    },
    
    arrowTooltip: function Ext_Toolbar_SplitButtonConfig$arrowTooltip(value) {
        /// <summary>
        /// The title attribute of the arrow
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['arrowTooltip'] = value;
        return this;
    },
    
    text: function Ext_Toolbar_SplitButtonConfig$text(value) {
        /// <summary>
        /// The button text
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    icon: function Ext_Toolbar_SplitButtonConfig$icon(value) {
        /// <summary>
        /// The path to an image to display in the button (the image will be set as the background-image
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    handler: function Ext_Toolbar_SplitButtonConfig$handler(value) {
        /// <summary>
        /// A function called when the button is clicked (can be used instead of click event)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['handler'] = value;
        return this;
    },
    
    scope: function Ext_Toolbar_SplitButtonConfig$scope(value) {
        /// <summary>
        /// The scope of the handler
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['scope'] = value;
        return this;
    },
    
    minWidth: function Ext_Toolbar_SplitButtonConfig$minWidth(value) {
        /// <summary>
        /// The minimum width for this button (used to give a set of buttons a common width)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['minWidth'] = value;
        return this;
    },
    
    tooltip: function Ext_Toolbar_SplitButtonConfig$tooltip(value) {
        /// <summary>
        /// {String/Object} The tooltip for the button - can be a string or QuickTips config object
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['tooltip'] = value;
        return this;
    },
    
    hidden: function Ext_Toolbar_SplitButtonConfig$hidden(value) {
        /// <summary>
        /// True to start hidden (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['hidden'] = value;
        return this;
    },
    
    disabled: function Ext_Toolbar_SplitButtonConfig$disabled(value) {
        /// <summary>
        /// True to start disabled (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    pressed: function Ext_Toolbar_SplitButtonConfig$pressed(value) {
        /// <summary>
        /// True to start pressed (only if enableToggle = true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['pressed'] = value;
        return this;
    },
    
    toggleGroup: function Ext_Toolbar_SplitButtonConfig$toggleGroup(value) {
        /// <summary>
        /// The group this toggle button is a member of (only 1 per group can be pressed, only
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['toggleGroup'] = value;
        return this;
    },
    
    repeat: function Ext_Toolbar_SplitButtonConfig$repeat(value) {
        /// <summary>
        /// {Boolean/Object} True to repeat fire the click event while the mouse is down. This can also be
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['repeat'] = value;
        return this;
    },
    
    tabIndex: function Ext_Toolbar_SplitButtonConfig$tabIndex(value) {
        /// <summary>
        /// Set a DOM tabIndex for this button (defaults to undefined)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    allowDepress: function Ext_Toolbar_SplitButtonConfig$allowDepress(value) {
        /// <summary>
        /// True to allow a pressed Button to be depressed (defaults to false). Only valid when {@link #enableToggle} is true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['allowDepress'] = value;
        return this;
    },
    
    enableToggle: function Ext_Toolbar_SplitButtonConfig$enableToggle(value) {
        /// <summary>
        /// True to enable pressed/not pressed toggling (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['enableToggle'] = value;
        return this;
    },
    
    toggleHandler: function Ext_Toolbar_SplitButtonConfig$toggleHandler(value) {
        /// <summary>
        /// Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:<ul class="mdetail-params"><li><b>button</b> : Ext.Button<div class="sub-desc">this Button object</div></li><li><b>state</b> : Boolean<div class="sub-desc">The next state if the Button, true means pressed.</div></li></ul>
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['toggleHandler'] = value;
        return this;
    },
    
    menu: function Ext_Toolbar_SplitButtonConfig$menu(value) {
        /// <summary>
        /// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['menu'] = value;
        return this;
    },
    
    menuAlign: function Ext_Toolbar_SplitButtonConfig$menuAlign(value) {
        /// <summary>
        /// The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['menuAlign'] = value;
        return this;
    },
    
    iconCls: function Ext_Toolbar_SplitButtonConfig$iconCls(value) {
        /// <summary>
        /// A css class which sets a background image to be used as the icon for this button
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    type: function Ext_Toolbar_SplitButtonConfig$type(value) {
        /// <summary>
        /// submit, reset or button - defaults to 'button'
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['type'] = value;
        return this;
    },
    
    clickEvent: function Ext_Toolbar_SplitButtonConfig$clickEvent(value) {
        /// <summary>
        /// The type of event to map to the button's event handler (defaults to 'click')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['clickEvent'] = value;
        return this;
    },
    
    handleMouseEvents: function Ext_Toolbar_SplitButtonConfig$handleMouseEvents(value) {
        /// <summary>
        /// False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['handleMouseEvents'] = value;
        return this;
    },
    
    tooltipType: function Ext_Toolbar_SplitButtonConfig$tooltipType(value) {
        /// <summary>
        /// The type of tooltip to use. Either "qtip" (default) for QuickTips or "title" for title attribute.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['tooltipType'] = value;
        return this;
    },
    
    template: function Ext_Toolbar_SplitButtonConfig$template(value) {
        /// <summary>
        /// (Optional) An {@link Ext.Template} with which to create the Button's main element. This Template must contain numeric substitution parameter 0 if it is to display the text property. Changing the template could require code modifications if required elements (e.g. a button) aren't present.
        /// </summary>
        /// <param name="value" type="Ext.Template">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['template'] = value;
        return this;
    },
    
    cls: function Ext_Toolbar_SplitButtonConfig$cls(value) {
        /// <summary>
        /// A CSS class string to apply to the button's main element.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    xtype: function Ext_Toolbar_SplitButtonConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_Toolbar_SplitButtonConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_Toolbar_SplitButtonConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_Toolbar_SplitButtonConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_Toolbar_SplitButtonConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_Toolbar_SplitButtonConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_Toolbar_SplitButtonConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_Toolbar_SplitButtonConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_Toolbar_SplitButtonConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_Toolbar_SplitButtonConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_Toolbar_SplitButtonConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_Toolbar_SplitButtonConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_Toolbar_SplitButtonConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_Toolbar_SplitButtonConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_Toolbar_SplitButtonConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_Toolbar_SplitButtonConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_Toolbar_SplitButtonConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_Toolbar_SplitButtonConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.SplitButtonConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_SplitButtonConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Toolbar.TextItemConfig

Ext.Toolbar.TextItemConfig = function Ext_Toolbar_TextItemConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Toolbar.TextItemConfig.prototype = {
    
    custom: function Ext_Toolbar_TextItemConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Toolbar.TextItemConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Toolbar_TextItemConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.tree');

////////////////////////////////////////////////////////////////////////////////
// Ext.tree.AsyncTreeNodeConfig

Ext.tree.AsyncTreeNodeConfig = function Ext_tree_AsyncTreeNodeConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.AsyncTreeNodeConfig.prototype = {
    
    loader: function Ext_tree_AsyncTreeNodeConfig$loader(value) {
        /// <summary>
        /// A TreeLoader to be used by this node (defaults to the loader defined on the tree)
        /// </summary>
        /// <param name="value" type="Ext.tree.TreeLoader">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['loader'] = value;
        return this;
    },
    
    text: function Ext_tree_AsyncTreeNodeConfig$text(value) {
        /// <summary>
        /// The text for this node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    expanded: function Ext_tree_AsyncTreeNodeConfig$expanded(value) {
        /// <summary>
        /// true to start the node expanded
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['expanded'] = value;
        return this;
    },
    
    allowDrag: function Ext_tree_AsyncTreeNodeConfig$allowDrag(value) {
        /// <summary>
        /// False to make this node undraggable if {@link #draggable} = true (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['allowDrag'] = value;
        return this;
    },
    
    allowDrop: function Ext_tree_AsyncTreeNodeConfig$allowDrop(value) {
        /// <summary>
        /// False if this node cannot have child nodes dropped on it (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['allowDrop'] = value;
        return this;
    },
    
    disabled: function Ext_tree_AsyncTreeNodeConfig$disabled(value) {
        /// <summary>
        /// true to start the node disabled
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    icon: function Ext_tree_AsyncTreeNodeConfig$icon(value) {
        /// <summary>
        /// The path to an icon for the node. The preferred way to do this
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    cls: function Ext_tree_AsyncTreeNodeConfig$cls(value) {
        /// <summary>
        /// A css class to be added to the node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    iconCls: function Ext_tree_AsyncTreeNodeConfig$iconCls(value) {
        /// <summary>
        /// A css class to be added to the nodes icon element for applying css background images
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    href: function Ext_tree_AsyncTreeNodeConfig$href(value) {
        /// <summary>
        /// URL of the link used for the node (defaults to #)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['href'] = value;
        return this;
    },
    
    hrefTarget: function Ext_tree_AsyncTreeNodeConfig$hrefTarget(value) {
        /// <summary>
        /// target frame for the link
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['hrefTarget'] = value;
        return this;
    },
    
    qtip: function Ext_tree_AsyncTreeNodeConfig$qtip(value) {
        /// <summary>
        /// An Ext QuickTip for the node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['qtip'] = value;
        return this;
    },
    
    expandable: function Ext_tree_AsyncTreeNodeConfig$expandable(value) {
        /// <summary>
        /// If set to true, the node will always show a plus/minus icon, even when empty
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['expandable'] = value;
        return this;
    },
    
    qtipCfg: function Ext_tree_AsyncTreeNodeConfig$qtipCfg(value) {
        /// <summary>
        /// An Ext QuickTip config for the node (used instead of qtip)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['qtipCfg'] = value;
        return this;
    },
    
    singleClickExpand: function Ext_tree_AsyncTreeNodeConfig$singleClickExpand(value) {
        /// <summary>
        /// True for single click expand on this node
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['singleClickExpand'] = value;
        return this;
    },
    
    uiProvider: function Ext_tree_AsyncTreeNodeConfig$uiProvider(value) {
        /// <summary>
        /// A UI <b>class</b> to use for this node (defaults to Ext.tree.TreeNodeUI)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['uiProvider'] = value;
        return this;
    },
    
    checked_: function Ext_tree_AsyncTreeNodeConfig$checked_(value) {
        /// <summary>
        /// True to render a checked checkbox for this node, false to render an unchecked checkbox
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['checked'] = value;
        return this;
    },
    
    draggable: function Ext_tree_AsyncTreeNodeConfig$draggable(value) {
        /// <summary>
        /// True to make this node draggable (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    isTarget: function Ext_tree_AsyncTreeNodeConfig$isTarget(value) {
        /// <summary>
        /// False to not allow this node to act as a drop target (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['isTarget'] = value;
        return this;
    },
    
    allowChildren: function Ext_tree_AsyncTreeNodeConfig$allowChildren(value) {
        /// <summary>
        /// False to not allow this node to have child nodes (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['allowChildren'] = value;
        return this;
    },
    
    leaf: function Ext_tree_AsyncTreeNodeConfig$leaf(value) {
        /// <summary>
        /// true if this node is a leaf and does not have children
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['leaf'] = value;
        return this;
    },
    
    id: function Ext_tree_AsyncTreeNodeConfig$id(value) {
        /// <summary>
        /// The id for this node. If one is not specified, one is generated.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    listeners: function Ext_tree_AsyncTreeNodeConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_AsyncTreeNodeConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.AsyncTreeNodeConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_AsyncTreeNodeConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.AsyncTreeNodeEvents

Ext.tree.AsyncTreeNodeEvents = function Ext_tree_AsyncTreeNodeEvents() {
}
Ext.tree.AsyncTreeNodeEvents.get_beforeload = function Ext_tree_AsyncTreeNodeEvents$get_beforeload() {
    /// <summary>
    /// Fires before this node is loaded, return false to cancel
    /// <pre><code>
    /// USAGE: ({Node} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeload';
}
Ext.tree.AsyncTreeNodeEvents.get_load = function Ext_tree_AsyncTreeNodeEvents$get_load() {
    /// <summary>
    /// Fires when this node is loaded
    /// <pre><code>
    /// USAGE: ({Node} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'load';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.DefaultSelectionModelConfig

Ext.tree.DefaultSelectionModelConfig = function Ext_tree_DefaultSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.DefaultSelectionModelConfig.prototype = {
    
    listeners: function Ext_tree_DefaultSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.DefaultSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_DefaultSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.DefaultSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_DefaultSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.DefaultSelectionModelEvents

Ext.tree.DefaultSelectionModelEvents = function Ext_tree_DefaultSelectionModelEvents() {
}
Ext.tree.DefaultSelectionModelEvents.get_selectionchange = function Ext_tree_DefaultSelectionModelEvents$get_selectionchange() {
    /// <summary>
    /// Fires when the selected node changes
    /// <pre><code>
    /// USAGE: ({DefaultSelectionModel} objthis, {TreeNode} node)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description>the new selection</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'selectionchange';
}
Ext.tree.DefaultSelectionModelEvents.get_beforeselect = function Ext_tree_DefaultSelectionModelEvents$get_beforeselect() {
    /// <summary>
    /// Fires before the selected node changes, return false to cancel the change
    /// <pre><code>
    /// USAGE: ({DefaultSelectionModel} objthis, {TreeNode} node, {TreeNode} node2)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description>the new selection</description></item><item><term><b>node2</b></term><description>the old selection</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeselect';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.MultiSelectionModelConfig

Ext.tree.MultiSelectionModelConfig = function Ext_tree_MultiSelectionModelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.MultiSelectionModelConfig.prototype = {
    
    listeners: function Ext_tree_MultiSelectionModelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.MultiSelectionModelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_MultiSelectionModelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.MultiSelectionModelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_MultiSelectionModelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.MultiSelectionModelEvents

Ext.tree.MultiSelectionModelEvents = function Ext_tree_MultiSelectionModelEvents() {
}
Ext.tree.MultiSelectionModelEvents.get_selectionchange = function Ext_tree_MultiSelectionModelEvents$get_selectionchange() {
    /// <summary>
    /// Fires when the selected nodes change
    /// <pre><code>
    /// USAGE: ({MultiSelectionModel} objthis, {Array} nodes)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>nodes</b></term><description>Array of the selected nodes</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'selectionchange';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.RootTreeNodeUIConfig

Ext.tree.RootTreeNodeUIConfig = function Ext_tree_RootTreeNodeUIConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.RootTreeNodeUIConfig.prototype = {
    
    custom: function Ext_tree_RootTreeNodeUIConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.RootTreeNodeUIConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_RootTreeNodeUIConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeDragZoneConfig

Ext.tree.TreeDragZoneConfig = function Ext_tree_TreeDragZoneConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeDragZoneConfig.prototype = {
    
    ddGroup: function Ext_tree_TreeDragZoneConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to 'TreeDD').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    containerScroll: function Ext_tree_TreeDragZoneConfig$containerScroll(value) {
        /// <summary>
        /// True to register this container with the Scrollmanager for auto scrolling during drag operations.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o['containerScroll'] = value;
        return this;
    },
    
    hlColor: function Ext_tree_TreeDragZoneConfig$hlColor(value) {
        /// <summary>
        /// The color to use when visually highlighting the drag source in the afterRepair method after a failed drop (defaults to "c3daf9" - light blue)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o['hlColor'] = value;
        return this;
    },
    
    dropAllowed: function Ext_tree_TreeDragZoneConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_tree_TreeDragZoneConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeDragZoneConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeDragZoneConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeDragZoneConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeDropZoneConfig

Ext.tree.TreeDropZoneConfig = function Ext_tree_TreeDropZoneConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeDropZoneConfig.prototype = {
    
    allowParentInsert: function Ext_tree_TreeDropZoneConfig$allowParentInsert(value) {
        /// <summary>
        /// Allow inserting a dragged node between an expanded parent node and its first child that will become a sibling of the parent when dropped (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['allowParentInsert'] = value;
        return this;
    },
    
    allowContainerDrop: function Ext_tree_TreeDropZoneConfig$allowContainerDrop(value) {
        /// <summary>
        /// True if drops on the tree container (outside of a specific tree node) are allowed (defaults to false)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['allowContainerDrop'] = value;
        return this;
    },
    
    appendOnly: function Ext_tree_TreeDropZoneConfig$appendOnly(value) {
        /// <summary>
        /// True if the tree should only allow append drops (use for trees which are sorted, defaults to false)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['appendOnly'] = value;
        return this;
    },
    
    ddGroup: function Ext_tree_TreeDropZoneConfig$ddGroup(value) {
        /// <summary>
        /// A named drag drop group to which this object belongs.  If a group is specified, then this object will only interact with other drag drop objects in the same group (defaults to 'TreeDD').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    expandDelay: function Ext_tree_TreeDropZoneConfig$expandDelay(value) {
        /// <summary>
        /// The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node over the target (defaults to 1000)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['expandDelay'] = value;
        return this;
    },
    
    overClass: function Ext_tree_TreeDropZoneConfig$overClass(value) {
        /// <summary>
        /// The CSS class applied to the drop target element while the drag source is over it (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['overClass'] = value;
        return this;
    },
    
    dropAllowed: function Ext_tree_TreeDropZoneConfig$dropAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['dropAllowed'] = value;
        return this;
    },
    
    dropNotAllowed: function Ext_tree_TreeDropZoneConfig$dropNotAllowed(value) {
        /// <summary>
        /// The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o['dropNotAllowed'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeDropZoneConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeDropZoneConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeDropZoneConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeEditorConfig

Ext.tree.TreeEditorConfig = function Ext_tree_TreeEditorConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeEditorConfig.prototype = {
    
    alignment: function Ext_tree_TreeEditorConfig$alignment(value) {
        /// <summary>
        /// The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "l-l").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['alignment'] = value;
        return this;
    },
    
    hideEl: function Ext_tree_TreeEditorConfig$hideEl(value) {
        /// <summary>
        /// True to hide the bound element while the editor is displayed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['hideEl'] = value;
        return this;
    },
    
    cls: function Ext_tree_TreeEditorConfig$cls(value) {
        /// <summary>
        /// CSS class to apply to the editor (defaults to "x-small-editor x-tree-editor")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    shim: function Ext_tree_TreeEditorConfig$shim(value) {
        /// <summary>
        /// True to shim the editor if selects/iframes could be displayed beneath it (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    maxWidth: function Ext_tree_TreeEditorConfig$maxWidth(value) {
        /// <summary>
        /// The maximum width in pixels of the editor field (defaults to 250).  Note that if the maxWidth would exceed the containing tree element's size, it will be automatically limited for you to the container width, taking scroll and client offsets into account prior to each edit.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['maxWidth'] = value;
        return this;
    },
    
    editDelay: function Ext_tree_TreeEditorConfig$editDelay(value) {
        /// <summary>
        /// The number of milliseconds between clicks to register a double-click that will trigger editing on the current node (defaults to 350).  If two clicks occur on the same node within this time span, the editor for the node will display, otherwise it will be processed as a regular click.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['editDelay'] = value;
        return this;
    },
    
    autoSize: function Ext_tree_TreeEditorConfig$autoSize(value) {
        /// <summary>
        /// {Boolean/String}  True for the editor to automatically adopt the size of the underlying field, "width" to adopt the width only, or "height" to adopt the height only (defaults to false)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['autoSize'] = value;
        return this;
    },
    
    revertInvalid: function Ext_tree_TreeEditorConfig$revertInvalid(value) {
        /// <summary>
        /// True to automatically revert the field value and cancel the edit when the user completes an edit and the field validation fails (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['revertInvalid'] = value;
        return this;
    },
    
    ignoreNoChange: function Ext_tree_TreeEditorConfig$ignoreNoChange(value) {
        /// <summary>
        /// True to skip the the edit completion process (no save, no events fired) if the user completes an edit and the value has not changed (defaults to false).  Applies only to string values - edits for other data types will never be ignored.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['ignoreNoChange'] = value;
        return this;
    },
    
    value: function Ext_tree_TreeEditorConfig$value(value) {
        /// <summary>
        /// The data value of the underlying field (defaults to "")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    shadow: function Ext_tree_TreeEditorConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop" for bottom-right shadow (defaults to "frame")
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    constrain: function Ext_tree_TreeEditorConfig$constrain(value) {
        /// <summary>
        /// True to constrain the editor to the viewport
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['constrain'] = value;
        return this;
    },
    
    swallowKeys: function Ext_tree_TreeEditorConfig$swallowKeys(value) {
        /// <summary>
        /// Handle the keydown/keypress events so they don't propagate (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['swallowKeys'] = value;
        return this;
    },
    
    completeOnEnter: function Ext_tree_TreeEditorConfig$completeOnEnter(value) {
        /// <summary>
        /// True to complete the edit when the enter key is pressed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['completeOnEnter'] = value;
        return this;
    },
    
    cancelOnEsc: function Ext_tree_TreeEditorConfig$cancelOnEsc(value) {
        /// <summary>
        /// True to cancel the edit when the escape key is pressed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['cancelOnEsc'] = value;
        return this;
    },
    
    updateEl: function Ext_tree_TreeEditorConfig$updateEl(value) {
        /// <summary>
        /// True to update the innerHTML of the bound element when the update completes (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['updateEl'] = value;
        return this;
    },
    
    xtype: function Ext_tree_TreeEditorConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_tree_TreeEditorConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_tree_TreeEditorConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_tree_TreeEditorConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_tree_TreeEditorConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_tree_TreeEditorConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_tree_TreeEditorConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_tree_TreeEditorConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_tree_TreeEditorConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_tree_TreeEditorConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_tree_TreeEditorConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_tree_TreeEditorConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_tree_TreeEditorConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_tree_TreeEditorConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_tree_TreeEditorConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_tree_TreeEditorConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_tree_TreeEditorConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeEditorConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeEditorConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeEditorConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeFilterConfig

Ext.tree.TreeFilterConfig = function Ext_tree_TreeFilterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeFilterConfig.prototype = {
    
    custom: function Ext_tree_TreeFilterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeFilterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeFilterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeLoaderConfig

Ext.tree.TreeLoaderConfig = function Ext_tree_TreeLoaderConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeLoaderConfig.prototype = {
    
    dataUrl: function Ext_tree_TreeLoaderConfig$dataUrl(value) {
        /// <summary>
        /// The URL from which to request a Json string which specifies an array of node definition objects representing the child nodes to be loaded.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['dataUrl'] = value;
        return this;
    },
    
    requestMethod: function Ext_tree_TreeLoaderConfig$requestMethod(value) {
        /// <summary>
        /// The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['requestMethod'] = value;
        return this;
    },
    
    url: function Ext_tree_TreeLoaderConfig$url(value) {
        /// <summary>
        /// Equivalent to {@link #dataUrl}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['url'] = value;
        return this;
    },
    
    preloadChildren: function Ext_tree_TreeLoaderConfig$preloadChildren(value) {
        /// <summary>
        /// If set to true, the loader recursively loads "children" attributes when doing the first load on nodes.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['preloadChildren'] = value;
        return this;
    },
    
    baseParams: function Ext_tree_TreeLoaderConfig$baseParams(value) {
        /// <summary>
        /// (optional) An object containing properties which specify HTTP parameters to be passed to each request for child nodes.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['baseParams'] = value;
        return this;
    },
    
    baseAttrs: function Ext_tree_TreeLoaderConfig$baseAttrs(value) {
        /// <summary>
        /// (optional) An object containing attributes to be added to all nodes created by this loader. If the attributes sent by the server have an attribute in this object, they take priority.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['baseAttrs'] = value;
        return this;
    },
    
    uiProviders: function Ext_tree_TreeLoaderConfig$uiProviders(value) {
        /// <summary>
        /// (optional) An object containing properties which specify custom {@link Ext.tree.TreeNodeUI} implementations. If the optional <i>uiProvider</i> attribute of a returned child node is a string rather than a reference to a TreeNodeUI implementation, then that string value is used as a property name in the uiProviders object.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['uiProviders'] = value;
        return this;
    },
    
    clearOnLoad: function Ext_tree_TreeLoaderConfig$clearOnLoad(value) {
        /// <summary>
        /// (optional) Default to true. Remove previously existing child nodes before loading.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['clearOnLoad'] = value;
        return this;
    },
    
    listeners: function Ext_tree_TreeLoaderConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeLoaderConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeLoaderConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeLoaderConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeLoaderEvents

Ext.tree.TreeLoaderEvents = function Ext_tree_TreeLoaderEvents() {
}
Ext.tree.TreeLoaderEvents.get_beforeload = function Ext_tree_TreeLoaderEvents$get_beforeload() {
    /// <summary>
    /// Fires before a network request is made to retrieve the Json text which specifies a node's children.
    /// <pre><code>
    /// USAGE: ({Object} This, {Object} node, {Object} callback)
    /// </code></pre><list type="bullet"><item><term><b>This</b></term><description>TreeLoader object.</description></item><item><term><b>node</b></term><description>The {@link Ext.tree.TreeNode} object being loaded.</description></item><item><term><b>callback</b></term><description>The callback function specified in the {@link #load} call.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeload';
}
Ext.tree.TreeLoaderEvents.get_load = function Ext_tree_TreeLoaderEvents$get_load() {
    /// <summary>
    /// Fires when the node has been successfuly loaded.
    /// <pre><code>
    /// USAGE: ({Object} This, {Object} node, {Object} response)
    /// </code></pre><list type="bullet"><item><term><b>This</b></term><description>TreeLoader object.</description></item><item><term><b>node</b></term><description>The {@link Ext.tree.TreeNode} object being loaded.</description></item><item><term><b>response</b></term><description>The response object containing the data from the server.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'load';
}
Ext.tree.TreeLoaderEvents.get_loadexception = function Ext_tree_TreeLoaderEvents$get_loadexception() {
    /// <summary>
    /// Fires if the network request failed.
    /// <pre><code>
    /// USAGE: ({Object} This, {Object} node, {Object} response)
    /// </code></pre><list type="bullet"><item><term><b>This</b></term><description>TreeLoader object.</description></item><item><term><b>node</b></term><description>The {@link Ext.tree.TreeNode} object being loaded.</description></item><item><term><b>response</b></term><description>The response object containing the data from the server.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'loadexception';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeNodeConfig

Ext.tree.TreeNodeConfig = function Ext_tree_TreeNodeConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeNodeConfig.prototype = {
    
    text: function Ext_tree_TreeNodeConfig$text(value) {
        /// <summary>
        /// The text for this node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['text'] = value;
        return this;
    },
    
    expanded: function Ext_tree_TreeNodeConfig$expanded(value) {
        /// <summary>
        /// true to start the node expanded
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['expanded'] = value;
        return this;
    },
    
    allowDrag: function Ext_tree_TreeNodeConfig$allowDrag(value) {
        /// <summary>
        /// False to make this node undraggable if {@link #draggable} = true (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['allowDrag'] = value;
        return this;
    },
    
    allowDrop: function Ext_tree_TreeNodeConfig$allowDrop(value) {
        /// <summary>
        /// False if this node cannot have child nodes dropped on it (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['allowDrop'] = value;
        return this;
    },
    
    disabled: function Ext_tree_TreeNodeConfig$disabled(value) {
        /// <summary>
        /// true to start the node disabled
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    icon: function Ext_tree_TreeNodeConfig$icon(value) {
        /// <summary>
        /// The path to an icon for the node. The preferred way to do this
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['icon'] = value;
        return this;
    },
    
    cls: function Ext_tree_TreeNodeConfig$cls(value) {
        /// <summary>
        /// A css class to be added to the node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    iconCls: function Ext_tree_TreeNodeConfig$iconCls(value) {
        /// <summary>
        /// A css class to be added to the nodes icon element for applying css background images
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    href: function Ext_tree_TreeNodeConfig$href(value) {
        /// <summary>
        /// URL of the link used for the node (defaults to #)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['href'] = value;
        return this;
    },
    
    hrefTarget: function Ext_tree_TreeNodeConfig$hrefTarget(value) {
        /// <summary>
        /// target frame for the link
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['hrefTarget'] = value;
        return this;
    },
    
    qtip: function Ext_tree_TreeNodeConfig$qtip(value) {
        /// <summary>
        /// An Ext QuickTip for the node
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['qtip'] = value;
        return this;
    },
    
    expandable: function Ext_tree_TreeNodeConfig$expandable(value) {
        /// <summary>
        /// If set to true, the node will always show a plus/minus icon, even when empty
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['expandable'] = value;
        return this;
    },
    
    qtipCfg: function Ext_tree_TreeNodeConfig$qtipCfg(value) {
        /// <summary>
        /// An Ext QuickTip config for the node (used instead of qtip)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['qtipCfg'] = value;
        return this;
    },
    
    singleClickExpand: function Ext_tree_TreeNodeConfig$singleClickExpand(value) {
        /// <summary>
        /// True for single click expand on this node
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['singleClickExpand'] = value;
        return this;
    },
    
    uiProvider: function Ext_tree_TreeNodeConfig$uiProvider(value) {
        /// <summary>
        /// A UI <b>class</b> to use for this node (defaults to Ext.tree.TreeNodeUI)
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['uiProvider'] = value;
        return this;
    },
    
    checked_: function Ext_tree_TreeNodeConfig$checked_(value) {
        /// <summary>
        /// True to render a checked checkbox for this node, false to render an unchecked checkbox
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['checked'] = value;
        return this;
    },
    
    draggable: function Ext_tree_TreeNodeConfig$draggable(value) {
        /// <summary>
        /// True to make this node draggable (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    isTarget: function Ext_tree_TreeNodeConfig$isTarget(value) {
        /// <summary>
        /// False to not allow this node to act as a drop target (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['isTarget'] = value;
        return this;
    },
    
    allowChildren: function Ext_tree_TreeNodeConfig$allowChildren(value) {
        /// <summary>
        /// False to not allow this node to have child nodes (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['allowChildren'] = value;
        return this;
    },
    
    leaf: function Ext_tree_TreeNodeConfig$leaf(value) {
        /// <summary>
        /// true if this node is a leaf and does not have children
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['leaf'] = value;
        return this;
    },
    
    id: function Ext_tree_TreeNodeConfig$id(value) {
        /// <summary>
        /// The id for this node. If one is not specified, one is generated.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    listeners: function Ext_tree_TreeNodeConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeNodeConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeNodeConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeNodeEvents

Ext.tree.TreeNodeEvents = function Ext_tree_TreeNodeEvents() {
}
Ext.tree.TreeNodeEvents.get_textchange = function Ext_tree_TreeNodeEvents$get_textchange() {
    /// <summary>
    /// Fires when the text for this node is changed
    /// <pre><code>
    /// USAGE: ({Node} objthis, {String} text, {String} oldText)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>text</b></term><description>The new text</description></item><item><term><b>oldText</b></term><description>The old text</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'textchange';
}
Ext.tree.TreeNodeEvents.get_beforeexpand = function Ext_tree_TreeNodeEvents$get_beforeexpand() {
    /// <summary>
    /// Fires before this node is expanded, return false to cancel.
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Boolean} deep, {Boolean} anim)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>deep</b></term><description></description></item><item><term><b>anim</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeexpand';
}
Ext.tree.TreeNodeEvents.get_beforecollapse = function Ext_tree_TreeNodeEvents$get_beforecollapse() {
    /// <summary>
    /// Fires before this node is collapsed, return false to cancel.
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Boolean} deep, {Boolean} anim)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>deep</b></term><description></description></item><item><term><b>anim</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecollapse';
}
Ext.tree.TreeNodeEvents.get_expand = function Ext_tree_TreeNodeEvents$get_expand() {
    /// <summary>
    /// Fires when this node is expanded
    /// <pre><code>
    /// USAGE: ({Node} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'expand';
}
Ext.tree.TreeNodeEvents.get_disabledchange = function Ext_tree_TreeNodeEvents$get_disabledchange() {
    /// <summary>
    /// Fires when the disabled status of this node changes
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Boolean} disabled)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>disabled</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'disabledchange';
}
Ext.tree.TreeNodeEvents.get_collapse = function Ext_tree_TreeNodeEvents$get_collapse() {
    /// <summary>
    /// Fires when this node is collapsed
    /// <pre><code>
    /// USAGE: ({Node} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'collapse';
}
Ext.tree.TreeNodeEvents.get_beforeclick = function Ext_tree_TreeNodeEvents$get_beforeclick() {
    /// <summary>
    /// Fires before click processing. Return false to cancel the default action.
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeclick';
}
Ext.tree.TreeNodeEvents.get_click = function Ext_tree_TreeNodeEvents$get_click() {
    /// <summary>
    /// Fires when this node is clicked
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.tree.TreeNodeEvents.get_checkchange = function Ext_tree_TreeNodeEvents$get_checkchange() {
    /// <summary>
    /// Fires when a node with a checkbox's checked property changes
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Boolean} chckd)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>chckd</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'checkchange';
}
Ext.tree.TreeNodeEvents.get_dblclick = function Ext_tree_TreeNodeEvents$get_dblclick() {
    /// <summary>
    /// Fires when this node is double clicked
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dblclick';
}
Ext.tree.TreeNodeEvents.get_contextmenu = function Ext_tree_TreeNodeEvents$get_contextmenu() {
    /// <summary>
    /// Fires when this node is right clicked
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'contextmenu';
}
Ext.tree.TreeNodeEvents.get_beforechildrenrendered = function Ext_tree_TreeNodeEvents$get_beforechildrenrendered() {
    /// <summary>
    /// Fires right before the child nodes for this node are rendered
    /// <pre><code>
    /// USAGE: ({Node} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforechildrenrendered';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeNodeUIConfig

Ext.tree.TreeNodeUIConfig = function Ext_tree_TreeNodeUIConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeNodeUIConfig.prototype = {
    
    custom: function Ext_tree_TreeNodeUIConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeNodeUIConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeNodeUIConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreePanelConfig

Ext.tree.TreePanelConfig = function Ext_tree_TreePanelConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreePanelConfig.prototype = {
    
    root: function Ext_tree_TreePanelConfig$root(value) {
        /// <summary>
        /// The root node for the tree.
        /// </summary>
        /// <param name="value" type="Ext.tree.TreeNode">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['root'] = value;
        return this;
    },
    
    rootVisible: function Ext_tree_TreePanelConfig$rootVisible(value) {
        /// <summary>
        /// false to hide the root node (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['rootVisible'] = value;
        return this;
    },
    
    lines: function Ext_tree_TreePanelConfig$lines(value) {
        /// <summary>
        /// false to disable tree lines (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['lines'] = value;
        return this;
    },
    
    enableDD: function Ext_tree_TreePanelConfig$enableDD(value) {
        /// <summary>
        /// true to enable drag and drop
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['enableDD'] = value;
        return this;
    },
    
    enableDrag: function Ext_tree_TreePanelConfig$enableDrag(value) {
        /// <summary>
        /// true to enable just drag
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['enableDrag'] = value;
        return this;
    },
    
    enableDrop: function Ext_tree_TreePanelConfig$enableDrop(value) {
        /// <summary>
        /// true to enable just drop
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['enableDrop'] = value;
        return this;
    },
    
    dragConfig: function Ext_tree_TreePanelConfig$dragConfig(value) {
        /// <summary>
        /// Custom config to pass to the {@link Ext.tree.TreeDragZone} instance
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['dragConfig'] = value;
        return this;
    },
    
    dropConfig: function Ext_tree_TreePanelConfig$dropConfig(value) {
        /// <summary>
        /// Custom config to pass to the {@link Ext.tree.TreeDropZone} instance
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['dropConfig'] = value;
        return this;
    },
    
    ddGroup: function Ext_tree_TreePanelConfig$ddGroup(value) {
        /// <summary>
        /// The DD group this TreePanel belongs to
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['ddGroup'] = value;
        return this;
    },
    
    ddAppendOnly: function Ext_tree_TreePanelConfig$ddAppendOnly(value) {
        /// <summary>
        /// True if the tree should only allow append drops (use for trees which are sorted)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['ddAppendOnly'] = value;
        return this;
    },
    
    ddScroll: function Ext_tree_TreePanelConfig$ddScroll(value) {
        /// <summary>
        /// true to enable body scrolling
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['ddScroll'] = value;
        return this;
    },
    
    containerScroll: function Ext_tree_TreePanelConfig$containerScroll(value) {
        /// <summary>
        /// true to register this container with ScrollManager
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['containerScroll'] = value;
        return this;
    },
    
    hlDrop: function Ext_tree_TreePanelConfig$hlDrop(value) {
        /// <summary>
        /// false to disable node highlight on drop (defaults to the value of Ext.enableFx)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['hlDrop'] = value;
        return this;
    },
    
    hlColor: function Ext_tree_TreePanelConfig$hlColor(value) {
        /// <summary>
        /// The color of the node highlight (defaults to C3DAF9)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['hlColor'] = value;
        return this;
    },
    
    animate: function Ext_tree_TreePanelConfig$animate(value) {
        /// <summary>
        /// true to enable animated expand/collapse (defaults to the value of Ext.enableFx)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['animate'] = value;
        return this;
    },
    
    singleExpand: function Ext_tree_TreePanelConfig$singleExpand(value) {
        /// <summary>
        /// true if only 1 node per branch may be expanded
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['singleExpand'] = value;
        return this;
    },
    
    selModel: function Ext_tree_TreePanelConfig$selModel(value) {
        /// <summary>
        /// A tree selection model to use with this TreePanel (defaults to a {@link Ext.tree.DefaultSelectionModel})
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['selModel'] = value;
        return this;
    },
    
    trackMouseOver: function Ext_tree_TreePanelConfig$trackMouseOver(value) {
        /// <summary>
        /// False to disable mouse over highlighting
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['trackMouseOver'] = value;
        return this;
    },
    
    loader: function Ext_tree_TreePanelConfig$loader(value) {
        /// <summary>
        /// A {@link Ext.tree.TreeLoader} for use with this TreePanel
        /// </summary>
        /// <param name="value" type="Ext.tree.TreeLoader">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['loader'] = value;
        return this;
    },
    
    pathSeparator: function Ext_tree_TreePanelConfig$pathSeparator(value) {
        /// <summary>
        /// The token used to separate sub-paths in path strings (defaults to '/')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['pathSeparator'] = value;
        return this;
    },
    
    useArrows: function Ext_tree_TreePanelConfig$useArrows(value) {
        /// <summary>
        /// True to use Vista-style arrows in the tree (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['useArrows'] = value;
        return this;
    },
    
    applyTo: function Ext_tree_TreePanelConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some panel-specific structural markup.  When applyTo is used, constituent parts of the panel can be specified by CSS class name within the main element, and the panel will automatically create those components from that markup. Any required components not specified in the markup will be autogenerated if necessary. The following class names are supported (baseCls will be replaced by {@link #baseCls}): <ul><li>baseCls + '-header'</li><li>baseCls + '-header-text'</li><li>baseCls + '-bwrap'</li><li>baseCls + '-tbar'</li><li>baseCls + '-body'</li><li>baseCls + '-bbar'</li><li>baseCls + '-footer'</li></ul> Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the panel's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    tbar: function Ext_tree_TreePanelConfig$tbar(value) {
        /// <summary>
        /// {Object/Array}  The top toolbar of the panel.  This can be either an {@link Ext.Toolbar} object or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the top toolbar after render, use {@link #getTopToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['tbar'] = value;
        return this;
    },
    
    bbar: function Ext_tree_TreePanelConfig$bbar(value) {
        /// <summary>
        /// {Object/Array}  The bottom toolbar of the panel.  This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render. To access the bottom toolbar after render, use {@link #getBottomToolbar}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['bbar'] = value;
        return this;
    },
    
    header: function Ext_tree_TreePanelConfig$header(value) {
        /// <summary>
        /// True to create the header element explicitly, false to skip creating it.  By default, when header is not specified, if a {@link #title} is set the header will be created automatically, otherwise it will not.  If a title is set but header is explicitly set to false, the header will not be rendered.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['header'] = value;
        return this;
    },
    
    footer: function Ext_tree_TreePanelConfig$footer(value) {
        /// <summary>
        /// True to create the footer element explicitly, false to skip creating it.  By default, when footer is not specified, if one or more buttons have been added to the panel the footer will be created automatically, otherwise it will not.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['footer'] = value;
        return this;
    },
    
    title: function Ext_tree_TreePanelConfig$title(value) {
        /// <summary>
        /// The title text to display in the panel header (defaults to '').  When a title is specified the header element will automatically be created and displayed unless {@link #header} is explicitly set to false.  If you don't want to specify a title at config time, but you may want one later, you must either specify a non-empty title (a blank space ' ' will do) or header:true so that the container element will get created.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    buttons: function Ext_tree_TreePanelConfig$buttons(value) {
        /// <summary>
        /// An array of {@link Ext.Button} <b>configs</b> used to add buttons to the footer of this panel.
        /// </summary>
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['buttons'] = value;
        return this;
    },
    
    autoLoad: function Ext_tree_TreePanelConfig$autoLoad(value) {
        /// <summary>
        /// {Object/String/Function}  A valid url spec according to the Updater {@link Ext.Updater#update} method. If autoLoad is not null, the panel will attempt to load its contents immediately upon render.<p> The URL will become the default URL for this panel's {@link #body} element, so it may be {@link Ext.Element#refresh refresh}ed at any time.</p>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoLoad'] = value;
        return this;
    },
    
    frame: function Ext_tree_TreePanelConfig$frame(value) {
        /// <summary>
        /// True to render the panel with custom rounded borders, false to render with plain 1px square borders (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['frame'] = value;
        return this;
    },
    
    border: function Ext_tree_TreePanelConfig$border(value) {
        /// <summary>
        /// True to display the borders of the panel's body element, false to hide them (defaults to true).  By default, the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['border'] = value;
        return this;
    },
    
    bodyBorder: function Ext_tree_TreePanelConfig$bodyBorder(value) {
        /// <summary>
        /// True to display an interior border on the body element of the panel, false to hide it (defaults to true). This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display as a 1px wide inset border, giving the entire body element an inset appearance.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['bodyBorder'] = value;
        return this;
    },
    
    bodyStyle: function Ext_tree_TreePanelConfig$bodyStyle(value) {
        /// <summary>
        /// {String/Object/Function}  Custom CSS styles to be applied to the body element in the format expected by {@link Ext.Element#applyStyles} (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['bodyStyle'] = value;
        return this;
    },
    
    iconCls: function Ext_tree_TreePanelConfig$iconCls(value) {
        /// <summary>
        /// A CSS class that will provide a background image to be used as the header icon (defaults to '').  An example custom icon class would be something like: .my-icon { background: url(../images/my-icon.gif) 0 6px no-repeat !important;}
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['iconCls'] = value;
        return this;
    },
    
    collapsible: function Ext_tree_TreePanelConfig$collapsible(value) {
        /// <summary>
        /// True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into the header tool button area, false to keep the panel statically sized with no button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['collapsible'] = value;
        return this;
    },
    
    tools: function Ext_tree_TreePanelConfig$tools(value) {
        /// <param name="value" type="Array">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['tools'] = value;
        return this;
    },
    
    hideCollapseTool: function Ext_tree_TreePanelConfig$hideCollapseTool(value) {
        /// <summary>
        /// True to hide the expand/collapse toggle button when {@link #collapsible} = true, false to display it (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['hideCollapseTool'] = value;
        return this;
    },
    
    titleCollapse: function Ext_tree_TreePanelConfig$titleCollapse(value) {
        /// <summary>
        /// True to allow expanding and collapsing the panel (when {@link #collapsible} = true) by clicking anywhere in the header bar, false to allow it only by clicking to tool button (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['titleCollapse'] = value;
        return this;
    },
    
    autoScroll: function Ext_tree_TreePanelConfig$autoScroll(value) {
        /// <summary>
        /// True to use overflow:'auto' on the panel's body element and show scroll bars automatically when necessary, false to clip any overflowing content (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoScroll'] = value;
        return this;
    },
    
    floating: function Ext_tree_TreePanelConfig$floating(value) {
        /// <summary>
        /// True to float the panel (absolute position it with automatic shimming and shadow), false to display it inline where it is rendered (defaults to false).  Note that by default, setting floating to true will cause the panel to display at negative offsets so that it is hidden -- because the panel is absolute positioned, the position must be set explicitly after render (e.g., myPanel.setPosition(100,100);).  Also, when floating a panel you should always assign a fixed width, otherwise it will be auto width and will expand to fill to the right edge of the viewport.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['floating'] = value;
        return this;
    },
    
    shadow: function Ext_tree_TreePanelConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String}  True (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the panel, false to display no shadow (defaults to 'sides').  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    shadowOffset: function Ext_tree_TreePanelConfig$shadowOffset(value) {
        /// <summary>
        /// The number of pixels to offset the shadow if displayed (defaults to 4). Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['shadowOffset'] = value;
        return this;
    },
    
    shim: function Ext_tree_TreePanelConfig$shim(value) {
        /// <summary>
        /// False to disable the iframe shim in browsers which need one (defaults to true).  Note that this option only applies when floating = true.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['shim'] = value;
        return this;
    },
    
    html: function Ext_tree_TreePanelConfig$html(value) {
        /// <summary>
        /// {String/Object}  An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['html'] = value;
        return this;
    },
    
    contentEl: function Ext_tree_TreePanelConfig$contentEl(value) {
        /// <summary>
        /// The id of an existing HTML node to use as the panel's body content (defaults to '').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['contentEl'] = value;
        return this;
    },
    
    keys: function Ext_tree_TreePanelConfig$keys(value) {
        /// <summary>
        /// {Object/Array}  A KeyMap config object (in the format expected by {@link Ext.KeyMap#addBinding} used to assign custom key handling to this panel (defaults to null).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['keys'] = value;
        return this;
    },
    
    draggable: function Ext_tree_TreePanelConfig$draggable(value) {
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['draggable'] = value;
        return this;
    },
    
    tabTip: function Ext_tree_TreePanelConfig$tabTip(value) {
        /// <summary>
        /// Adds a tooltip when mousing over the tab of a Ext.Panel which is an item of a Ext.TabPanel. Ext.QuickTips.init() must be called in order for the tips to render.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['tabTip'] = value;
        return this;
    },
    
    baseCls: function Ext_tree_TreePanelConfig$baseCls(value) {
        /// <summary>
        /// The base CSS class to apply to this panel's element (defaults to 'x-panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['baseCls'] = value;
        return this;
    },
    
    collapsedCls: function Ext_tree_TreePanelConfig$collapsedCls(value) {
        /// <summary>
        /// A CSS class to add to the panel's element after it has been collapsed (defaults to 'x-panel-collapsed').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['collapsedCls'] = value;
        return this;
    },
    
    maskDisabled: function Ext_tree_TreePanelConfig$maskDisabled(value) {
        /// <summary>
        /// True to mask the panel when it is disabled, false to not mask it (defaults to true).  Either way, the panel will always tell its contained elements to disable themselves when it is disabled, but masking the panel can provide an additional visual cue that the panel is disabled.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['maskDisabled'] = value;
        return this;
    },
    
    animCollapse: function Ext_tree_TreePanelConfig$animCollapse(value) {
        /// <summary>
        /// True to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['animCollapse'] = value;
        return this;
    },
    
    headerAsText: function Ext_tree_TreePanelConfig$headerAsText(value) {
        /// <summary>
        /// True to display the panel title in the header, false to hide it (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['headerAsText'] = value;
        return this;
    },
    
    buttonAlign: function Ext_tree_TreePanelConfig$buttonAlign(value) {
        /// <summary>
        /// The alignment of any buttons added to this panel.  Valid values are 'right,' 'left' and 'center' (defaults to 'right').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['buttonAlign'] = value;
        return this;
    },
    
    collapsed: function Ext_tree_TreePanelConfig$collapsed(value) {
        /// <summary>
        /// True to render the panel collapsed, false to render it expanded (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['collapsed'] = value;
        return this;
    },
    
    collapseFirst: function Ext_tree_TreePanelConfig$collapseFirst(value) {
        /// <summary>
        /// True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the panel's title bar, false to render it last (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['collapseFirst'] = value;
        return this;
    },
    
    minButtonWidth: function Ext_tree_TreePanelConfig$minButtonWidth(value) {
        /// <summary>
        /// Minimum width in pixels of all buttons in this panel (defaults to 75)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['minButtonWidth'] = value;
        return this;
    },
    
    elements: function Ext_tree_TreePanelConfig$elements(value) {
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['elements'] = value;
        return this;
    },
    
    defaultType: function Ext_tree_TreePanelConfig$defaultType(value) {
        /// <summary>
        /// The default type of container represented by this object as registered in Ext.ComponentMgr (defaults to 'panel').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['defaultType'] = value;
        return this;
    },
    
    layout: function Ext_tree_TreePanelConfig$layout(value) {
        /// <summary>
        /// The layout type to be used in this container.  If not specified, a default {@link Ext.layout.ContainerLayout} will be created and used.  Valid values are: absolute, accordion, anchor, border, card, column, fit, form and table. Specific config values for the chosen layout type can be specified using {@link #layoutConfig}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['layout'] = value;
        return this;
    },
    
    layoutConfig: function Ext_tree_TreePanelConfig$layoutConfig(value) {
        /// <summary>
        /// This is a config object containing properties specific to the chosen layout (to be used in conjunction with the {@link #layout} config value).  For complete details regarding the valid config options for each layout type, see the layout class corresponding to the type specified:<ul class="mdetail-params"><li>{@link Ext.layout.Absolute}</li><li>{@link Ext.layout.Accordion}</li><li>{@link Ext.layout.AnchorLayout}</li><li>{@link Ext.layout.BorderLayout}</li><li>{@link Ext.layout.CardLayout}</li><li>{@link Ext.layout.ColumnLayout}</li><li>{@link Ext.layout.FitLayout}</li><li>{@link Ext.layout.FormLayout}</li><li>{@link Ext.layout.TableLayout}</li></ul>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['layoutConfig'] = value;
        return this;
    },
    
    bufferResize: function Ext_tree_TreePanelConfig$bufferResize(value) {
        /// <summary>
        /// {Boolean/Number}  When set to true (100 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers with a large quantity of sub-components for which frequent layout calls would be expensive.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['bufferResize'] = value;
        return this;
    },
    
    activeItem: function Ext_tree_TreePanelConfig$activeItem(value) {
        /// <summary>
        /// {String/Number}  A string component id or the numeric index of the component that should be initially activated within the container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first item in the container's collection).  activeItem only applies to layout styles that can display items one at a time (like {@link Ext.layout.Accordion}, {@link Ext.layout.CardLayout} and {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['activeItem'] = value;
        return this;
    },
    
    items: function Ext_tree_TreePanelConfig$items(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['items'] = value;
        return this;
    },
    
    defaults: function Ext_tree_TreePanelConfig$defaults(value) {
        /// <summary>
        /// A config object that will be applied to all components added to this container either via the {@link #items} config or via the {@link #add} or {@link #insert} methods.  The defaults config can contain any number of name/value property pairs to be added to each item, and should be valid for the types of items being added to the container.  For example, to automatically apply padding to the body of each of a set of contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['defaults'] = value;
        return this;
    },
    
    x: function Ext_tree_TreePanelConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_tree_TreePanelConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_tree_TreePanelConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_tree_TreePanelConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_tree_TreePanelConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_tree_TreePanelConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_tree_TreePanelConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_tree_TreePanelConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_tree_TreePanelConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_tree_TreePanelConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_tree_TreePanelConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    cls: function Ext_tree_TreePanelConfig$cls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element (defaults to '').  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    overCls: function Ext_tree_TreePanelConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_tree_TreePanelConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_tree_TreePanelConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_tree_TreePanelConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    renderTo: function Ext_tree_TreePanelConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_tree_TreePanelConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_tree_TreePanelConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_tree_TreePanelConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_tree_TreePanelConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_tree_TreePanelConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_tree_TreePanelConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_tree_TreePanelConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_tree_TreePanelConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreePanelConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreePanelConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreePanelConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreePanelEvents

Ext.tree.TreePanelEvents = function Ext_tree_TreePanelEvents() {
}
Ext.tree.TreePanelEvents.get_append = function Ext_tree_TreePanelEvents$get_append() {
    /// <summary>
    /// Fires when a new child node is appended to a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The newly appended node</description></item><item><term><b>index</b></term><description>The index of the newly appended node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'append';
}
Ext.tree.TreePanelEvents.get_remove = function Ext_tree_TreePanelEvents$get_remove() {
    /// <summary>
    /// Fires when a child node is removed from a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}
Ext.tree.TreePanelEvents.get_movenode = function Ext_tree_TreePanelEvents$get_movenode() {
    /// <summary>
    /// Fires when a node is moved to a new location in the tree
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} node, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>node</b></term><description>The node moved</description></item><item><term><b>oldParent</b></term><description>The old parent of this node</description></item><item><term><b>newParent</b></term><description>The new parent of this node</description></item><item><term><b>index</b></term><description>The index it was moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'movenode';
}
Ext.tree.TreePanelEvents.get_insert = function Ext_tree_TreePanelEvents$get_insert() {
    /// <summary>
    /// Fires when a new child node is inserted in a node in this tree.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node inserted</description></item><item><term><b>refNode</b></term><description>The child node the node was inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'insert';
}
Ext.tree.TreePanelEvents.get_beforeappend = function Ext_tree_TreePanelEvents$get_beforeappend() {
    /// <summary>
    /// Fires before a new child is appended to a node in this tree, return false to cancel the append.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be appended</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeappend';
}
Ext.tree.TreePanelEvents.get_beforeremove = function Ext_tree_TreePanelEvents$get_beforeremove() {
    /// <summary>
    /// Fires before a child is removed from a node in this tree, return false to cancel the remove.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be removed</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeremove';
}
Ext.tree.TreePanelEvents.get_beforemovenode = function Ext_tree_TreePanelEvents$get_beforemovenode() {
    /// <summary>
    /// Fires before a node is moved to a new location in the tree. Return false to cancel the move.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} node, {Node} oldParent, {Node} newParent, {Number} index)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>node</b></term><description>The node being moved</description></item><item><term><b>oldParent</b></term><description>The parent of the node</description></item><item><term><b>newParent</b></term><description>The new parent the node is moving to</description></item><item><term><b>index</b></term><description>The index it is being moved to</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforemovenode';
}
Ext.tree.TreePanelEvents.get_beforeinsert = function Ext_tree_TreePanelEvents$get_beforeinsert() {
    /// <summary>
    /// Fires before a new child is inserted in a node in this tree, return false to cancel the insert.
    /// <pre><code>
    /// USAGE: ({Tree} tree, {Node} parent, {Node} node, {Node} refNode)
    /// </code></pre><list type="bullet"><item><term><b>tree</b></term><description>The owner tree</description></item><item><term><b>parent</b></term><description>The parent node</description></item><item><term><b>node</b></term><description>The child node to be inserted</description></item><item><term><b>refNode</b></term><description>The child node the node is being inserted before</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeinsert';
}
Ext.tree.TreePanelEvents.get_beforeload = function Ext_tree_TreePanelEvents$get_beforeload() {
    /// <summary>
    /// Fires before a node is loaded, return false to cancel
    /// <pre><code>
    /// USAGE: ({Node} node)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node being loaded</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeload';
}
Ext.tree.TreePanelEvents.get_load = function Ext_tree_TreePanelEvents$get_load() {
    /// <summary>
    /// Fires when a node is loaded
    /// <pre><code>
    /// USAGE: ({Node} node)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node that was loaded</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'load';
}
Ext.tree.TreePanelEvents.get_textchange = function Ext_tree_TreePanelEvents$get_textchange() {
    /// <summary>
    /// Fires when the text for a node is changed
    /// <pre><code>
    /// USAGE: ({Node} node, {String} text, {String} oldText)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>text</b></term><description>The new text</description></item><item><term><b>oldText</b></term><description>The old text</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'textchange';
}
Ext.tree.TreePanelEvents.get_beforeexpandnode = function Ext_tree_TreePanelEvents$get_beforeexpandnode() {
    /// <summary>
    /// Fires before a node is expanded, return false to cancel.
    /// <pre><code>
    /// USAGE: ({Node} node, {Boolean} deep, {Boolean} anim)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>deep</b></term><description></description></item><item><term><b>anim</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeexpandnode';
}
Ext.tree.TreePanelEvents.get_beforecollapsenode = function Ext_tree_TreePanelEvents$get_beforecollapsenode() {
    /// <summary>
    /// Fires before a node is collapsed, return false to cancel.
    /// <pre><code>
    /// USAGE: ({Node} node, {Boolean} deep, {Boolean} anim)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>deep</b></term><description></description></item><item><term><b>anim</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforecollapsenode';
}
Ext.tree.TreePanelEvents.get_expandnode = function Ext_tree_TreePanelEvents$get_expandnode() {
    /// <summary>
    /// Fires when a node is expanded
    /// <pre><code>
    /// USAGE: ({Node} node)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'expandnode';
}
Ext.tree.TreePanelEvents.get_disabledchange = function Ext_tree_TreePanelEvents$get_disabledchange() {
    /// <summary>
    /// Fires when the disabled status of a node changes
    /// <pre><code>
    /// USAGE: ({Node} node, {Boolean} disabled)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>disabled</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'disabledchange';
}
Ext.tree.TreePanelEvents.get_collapsenode = function Ext_tree_TreePanelEvents$get_collapsenode() {
    /// <summary>
    /// Fires when a node is collapsed
    /// <pre><code>
    /// USAGE: ({Node} node)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'collapsenode';
}
Ext.tree.TreePanelEvents.get_beforeclick = function Ext_tree_TreePanelEvents$get_beforeclick() {
    /// <summary>
    /// Fires before click processing on a node. Return false to cancel the default action.
    /// <pre><code>
    /// USAGE: ({Node} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforeclick';
}
Ext.tree.TreePanelEvents.get_click = function Ext_tree_TreePanelEvents$get_click() {
    /// <summary>
    /// Fires when a node is clicked
    /// <pre><code>
    /// USAGE: ({Node} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.tree.TreePanelEvents.get_checkchange = function Ext_tree_TreePanelEvents$get_checkchange() {
    /// <summary>
    /// Fires when a node with a checkbox's checked property changes
    /// <pre><code>
    /// USAGE: ({Node} objthis, {Boolean} chckd)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description>This node</description></item><item><term><b>chckd</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'checkchange';
}
Ext.tree.TreePanelEvents.get_dblclick = function Ext_tree_TreePanelEvents$get_dblclick() {
    /// <summary>
    /// Fires when a node is double clicked
    /// <pre><code>
    /// USAGE: ({Node} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dblclick';
}
Ext.tree.TreePanelEvents.get_contextmenu = function Ext_tree_TreePanelEvents$get_contextmenu() {
    /// <summary>
    /// Fires when a node is right clicked
    /// <pre><code>
    /// USAGE: ({Node} node, {Ext.EventObject} e)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item><item><term><b>e</b></term><description>The event object</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'contextmenu';
}
Ext.tree.TreePanelEvents.get_beforechildrenrendered = function Ext_tree_TreePanelEvents$get_beforechildrenrendered() {
    /// <summary>
    /// Fires right before the child nodes for a node are rendered
    /// <pre><code>
    /// USAGE: ({Node} node)
    /// </code></pre><list type="bullet"><item><term><b>node</b></term><description>The node</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforechildrenrendered';
}
Ext.tree.TreePanelEvents.get_startdrag = function Ext_tree_TreePanelEvents$get_startdrag() {
    /// <summary>
    /// Fires when a node starts being dragged
    /// <pre><code>
    /// USAGE: ({Ext.tree.TreePanel} objthis, {Ext.tree.TreeNode} node, {event} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description></description></item><item><term><b>e</b></term><description>The raw browser event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'startdrag';
}
Ext.tree.TreePanelEvents.get_enddrag = function Ext_tree_TreePanelEvents$get_enddrag() {
    /// <summary>
    /// Fires when a drag operation is complete
    /// <pre><code>
    /// USAGE: ({Ext.tree.TreePanel} objthis, {Ext.tree.TreeNode} node, {event} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description></description></item><item><term><b>e</b></term><description>The raw browser event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'enddrag';
}
Ext.tree.TreePanelEvents.get_dragdrop = function Ext_tree_TreePanelEvents$get_dragdrop() {
    /// <summary>
    /// Fires when a dragged node is dropped on a valid DD target
    /// <pre><code>
    /// USAGE: ({Ext.tree.TreePanel} objthis, {Ext.tree.TreeNode} node, {DD} dd, {event} e)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item><item><term><b>node</b></term><description></description></item><item><term><b>dd</b></term><description>The dd it was dropped on</description></item><item><term><b>e</b></term><description>The raw browser event</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'dragdrop';
}
Ext.tree.TreePanelEvents.get_beforenodedrop = function Ext_tree_TreePanelEvents$get_beforenodedrop() {
    /// <summary>
    /// Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent
    /// passed to handlers has the following properties:<br /><ul style="padding:5px;padding-left:16px;"><li>tree - The TreePanel</li><li>target - The node being targeted for the drop</li><li>data - The drag data from the drag source</li><li>point - The point of the drop - append, above or below</li><li>source - The drag source</li><li>rawEvent - Raw mouse event</li><li>dropNode - Drop node(s) provided by the source <b>OR</b> you can supply node(s)
    /// to be inserted by setting them on this object.</li><li>cancel - Set this to true to cancel the drop.</li><li>dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true
    /// will prevent the animated "repair" from appearing.</li></ul><pre><code>
    /// USAGE: ({Object} dropEvent)
    /// </code></pre><list type="bullet"><item><term><b>dropEvent</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'beforenodedrop';
}
Ext.tree.TreePanelEvents.get_nodedrop = function Ext_tree_TreePanelEvents$get_nodedrop() {
    /// <summary>
    /// Fires after a DD object is dropped on a node in this tree. The dropEvent
    /// passed to handlers has the following properties:<br /><ul style="padding:5px;padding-left:16px;"><li>tree - The TreePanel</li><li>target - The node being targeted for the drop</li><li>data - The drag data from the drag source</li><li>point - The point of the drop - append, above or below</li><li>source - The drag source</li><li>rawEvent - Raw mouse event</li><li>dropNode - Dropped node(s).</li></ul><pre><code>
    /// USAGE: ({Object} dropEvent)
    /// </code></pre><list type="bullet"><item><term><b>dropEvent</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'nodedrop';
}
Ext.tree.TreePanelEvents.get_nodedragover = function Ext_tree_TreePanelEvents$get_nodedragover() {
    /// <summary>
    /// Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent
    /// passed to handlers has the following properties:<br /><ul style="padding:5px;padding-left:16px;"><li>tree - The TreePanel</li><li>target - The node being targeted for the drop</li><li>data - The drag data from the drag source</li><li>point - The point of the drop - append, above or below</li><li>source - The drag source</li><li>rawEvent - Raw mouse event</li><li>dropNode - Drop node(s) provided by the source.</li><li>cancel - Set this to true to signal drop not allowed.</li></ul><pre><code>
    /// USAGE: ({Object} dragOverEvent)
    /// </code></pre><list type="bullet"><item><term><b>dragOverEvent</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'nodedragover';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.tree.TreeSorterConfig

Ext.tree.TreeSorterConfig = function Ext_tree_TreeSorterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.tree.TreeSorterConfig.prototype = {
    
    folderSort: function Ext_tree_TreeSorterConfig$folderSort(value) {
        /// <summary>
        /// True to sort leaf nodes under non-leaf nodes (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['folderSort'] = value;
        return this;
    },
    
    property: function Ext_tree_TreeSorterConfig$property(value) {
        /// <summary>
        /// The named attribute on the node to sort by (defaults to "text").  Note that this property is only used if no {@link #sortType} function is specified, otherwise it is ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['property'] = value;
        return this;
    },
    
    dir: function Ext_tree_TreeSorterConfig$dir(value) {
        /// <summary>
        /// The direction to sort ("asc" or "desc," case-insensitive, defaults to "asc")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['dir'] = value;
        return this;
    },
    
    leafAttr: function Ext_tree_TreeSorterConfig$leafAttr(value) {
        /// <summary>
        /// The attribute used to determine leaf nodes when {@link #folderSort} = true (defaults to "leaf")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['leafAttr'] = value;
        return this;
    },
    
    caseSensitive: function Ext_tree_TreeSorterConfig$caseSensitive(value) {
        /// <summary>
        /// true for case-sensitive sort (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['caseSensitive'] = value;
        return this;
    },
    
    sortType: function Ext_tree_TreeSorterConfig$sortType(value) {
        /// <summary>
        /// A custom "casting" function used to convert node values before sorting.  The function will be called with a single parameter (the {@link Ext.tree.TreeNode} being evaluated) and is expected to return the node's sort value cast to the specific data type required for sorting.  This could be used, for example, when a node's text (or other attribute) should be sorted as a date or numeric value.  See the class description for example usage.  Note that if a sortType is specified, any {@link #property} config will be ignored.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o['sortType'] = value;
        return this;
    },
    
    custom: function Ext_tree_TreeSorterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.tree.TreeSorterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_tree_TreeSorterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.Updater');

////////////////////////////////////////////////////////////////////////////////
// Ext.Updater.BasicRendererConfig

Ext.Updater.BasicRendererConfig = function Ext_Updater_BasicRendererConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Updater.BasicRendererConfig.prototype = {
    
    custom: function Ext_Updater_BasicRendererConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Updater.BasicRendererConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Updater_BasicRendererConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.Updater.defaultsConfig

Ext.Updater.defaultsConfig = function Ext_Updater_defaultsConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.Updater.defaultsConfig.prototype = {
    
    custom: function Ext_Updater_defaultsConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.Updater.defaultsConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_Updater_defaultsConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.util');

////////////////////////////////////////////////////////////////////////////////
// Ext.util.ClickRepeaterConfig

Ext.util.ClickRepeaterConfig = function Ext_util_ClickRepeaterConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.ClickRepeaterConfig.prototype = {
    
    el: function Ext_util_ClickRepeaterConfig$el(value) {
        /// <summary>
        /// The element to act as a button.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['el'] = value;
        return this;
    },
    
    delay: function Ext_util_ClickRepeaterConfig$delay(value) {
        /// <summary>
        /// The initial delay before the repeating event begins firing.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['delay'] = value;
        return this;
    },
    
    interval: function Ext_util_ClickRepeaterConfig$interval(value) {
        /// <summary>
        /// The interval between firings of the "click" event. Default 20 ms.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['interval'] = value;
        return this;
    },
    
    pressClass: function Ext_util_ClickRepeaterConfig$pressClass(value) {
        /// <summary>
        /// A CSS class name to be applied to the element while pressed.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['pressClass'] = value;
        return this;
    },
    
    accelerate: function Ext_util_ClickRepeaterConfig$accelerate(value) {
        /// <summary>
        /// True if autorepeating should start slowly and accelerate.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['accelerate'] = value;
        return this;
    },
    
    preventDefault: function Ext_util_ClickRepeaterConfig$preventDefault(value) {
        /// <summary>
        /// True to prevent the default click event
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['preventDefault'] = value;
        return this;
    },
    
    stopDefault: function Ext_util_ClickRepeaterConfig$stopDefault(value) {
        /// <summary>
        /// True to stop the default click event
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['stopDefault'] = value;
        return this;
    },
    
    listeners: function Ext_util_ClickRepeaterConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_util_ClickRepeaterConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.ClickRepeaterConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_ClickRepeaterConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.ClickRepeaterEvents

Ext.util.ClickRepeaterEvents = function Ext_util_ClickRepeaterEvents() {
}
Ext.util.ClickRepeaterEvents.get_mousedown = function Ext_util_ClickRepeaterEvents$get_mousedown() {
    /// <summary>
    /// Fires when the mouse button is depressed.
    /// <pre><code>
    /// USAGE: ({Ext.util.ClickRepeater} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mousedown';
}
Ext.util.ClickRepeaterEvents.get_click = function Ext_util_ClickRepeaterEvents$get_click() {
    /// <summary>
    /// Fires on a specified interval during the time the element is pressed.
    /// <pre><code>
    /// USAGE: ({Ext.util.ClickRepeater} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'click';
}
Ext.util.ClickRepeaterEvents.get_mouseup = function Ext_util_ClickRepeaterEvents$get_mouseup() {
    /// <summary>
    /// Fires when the mouse key is released.
    /// <pre><code>
    /// USAGE: ({Ext.util.ClickRepeater} objthis)
    /// </code></pre><list type="bullet"><item><term><b>objthis</b></term><description></description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'mouseup';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.CSSConfig

Ext.util.CSSConfig = function Ext_util_CSSConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.CSSConfig.prototype = {
    
    custom: function Ext_util_CSSConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.CSSConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_CSSConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.DelayedTaskConfig

Ext.util.DelayedTaskConfig = function Ext_util_DelayedTaskConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.DelayedTaskConfig.prototype = {
    
    custom: function Ext_util_DelayedTaskConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.DelayedTaskConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_DelayedTaskConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.FormatConfig

Ext.util.FormatConfig = function Ext_util_FormatConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.FormatConfig.prototype = {
    
    custom: function Ext_util_FormatConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.FormatConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_FormatConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.JSONConfig

Ext.util.JSONConfig = function Ext_util_JSONConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.JSONConfig.prototype = {
    
    custom: function Ext_util_JSONConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.JSONConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_JSONConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.MixedCollectionConfig

Ext.util.MixedCollectionConfig = function Ext_util_MixedCollectionConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.MixedCollectionConfig.prototype = {
    
    listeners: function Ext_util_MixedCollectionConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.MixedCollectionConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_util_MixedCollectionConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.MixedCollectionConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_MixedCollectionConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.MixedCollectionEvents

Ext.util.MixedCollectionEvents = function Ext_util_MixedCollectionEvents() {
}
Ext.util.MixedCollectionEvents.get_clear = function Ext_util_MixedCollectionEvents$get_clear() {
    /// <summary>
    /// Fires when the collection is cleared.
    /// <pre><code>
    /// USAGE: ()
    /// </code></pre><list type="bullet"></list>
    /// </summary>
    /// <value type="String"></value>
    return 'clear';
}
Ext.util.MixedCollectionEvents.get_add = function Ext_util_MixedCollectionEvents$get_add() {
    /// <summary>
    /// Fires when an item is added to the collection.
    /// <pre><code>
    /// USAGE: ({Number} index, {Object} o, {String} key)
    /// </code></pre><list type="bullet"><item><term><b>index</b></term><description>The index at which the item was added.</description></item><item><term><b>o</b></term><description>The item added.</description></item><item><term><b>key</b></term><description>The key associated with the added item.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'add';
}
Ext.util.MixedCollectionEvents.get_replace = function Ext_util_MixedCollectionEvents$get_replace() {
    /// <summary>
    /// Fires when an item is replaced in the collection.
    /// <pre><code>
    /// USAGE: ({String} key, {Object} old, {Object} newItem)
    /// </code></pre><list type="bullet"><item><term><b>key</b></term><description>he key associated with the new added.</description></item><item><term><b>old</b></term><description>The item being replaced.</description></item><item><term><b>newItem</b></term><description>The new item.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'replace';
}
Ext.util.MixedCollectionEvents.get_remove = function Ext_util_MixedCollectionEvents$get_remove() {
    /// <summary>
    /// Fires when an item is removed from the collection.
    /// <pre><code>
    /// USAGE: ({Object} o, {String} key)
    /// </code></pre><list type="bullet"><item><term><b>o</b></term><description>The item being removed.</description></item><item><term><b>key</b></term><description>(optional) The key associated with the removed item.</description></item></list>
    /// </summary>
    /// <value type="String"></value>
    return 'remove';
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.ObservableConfig

Ext.util.ObservableConfig = function Ext_util_ObservableConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.ObservableConfig.prototype = {
    
    listeners: function Ext_util_ObservableConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.ObservableConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_util_ObservableConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.ObservableConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_ObservableConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.TaskRunnerConfig

Ext.util.TaskRunnerConfig = function Ext_util_TaskRunnerConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.TaskRunnerConfig.prototype = {
    
    custom: function Ext_util_TaskRunnerConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.TaskRunnerConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_TaskRunnerConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Ext.util.TextMetricsConfig

Ext.util.TextMetricsConfig = function Ext_util_TextMetricsConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.util.TextMetricsConfig.prototype = {
    
    custom: function Ext_util_TextMetricsConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.util.TextMetricsConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_util_TextMetricsConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Type.createNamespace('Ext.ux.Andrie');

////////////////////////////////////////////////////////////////////////////////
// Ext.ux.Andrie.SelectConfig

Ext.ux.Andrie.SelectConfig = function Ext_ux_Andrie_SelectConfig() {
    /// <field name="o" type="Object">
    /// </field>
    this.o = {};
}
Ext.ux.Andrie.SelectConfig.prototype = {
    
    multiSelect: function Ext_ux_Andrie_SelectConfig$multiSelect(value) {
        /// <summary>
        /// Multiple selection is allowed (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['multiSelect'] = value;
        return this;
    },
    
    minLength: function Ext_ux_Andrie_SelectConfig$minLength(value) {
        /// <summary>
        /// Minimum number of required items to be selected
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['minLength'] = value;
        return this;
    },
    
    minLengthText: function Ext_ux_Andrie_SelectConfig$minLengthText(value) {
        /// <summary>
        /// Validation message displayed when minLength is not met.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['minLengthText'] = value;
        return this;
    },
    
    maxLength: function Ext_ux_Andrie_SelectConfig$maxLength(value) {
        /// <summary>
        /// Maximum number of allowed items to be selected
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['maxLength'] = value;
        return this;
    },
    
    maxLengthText: function Ext_ux_Andrie_SelectConfig$maxLengthText(value) {
        /// <summary>
        /// Validation message displayed when maxLength is not met.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['maxLengthText'] = value;
        return this;
    },
    
    clearTrigger: function Ext_ux_Andrie_SelectConfig$clearTrigger(value) {
        /// <summary>
        /// Show the clear button (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['clearTrigger'] = value;
        return this;
    },
    
    history: function Ext_ux_Andrie_SelectConfig$history(value) {
        /// <summary>
        /// Add selected value to the top of the list (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['history'] = value;
        return this;
    },
    
    historyMaxLength: function Ext_ux_Andrie_SelectConfig$historyMaxLength(value) {
        /// <summary>
        /// Number of entered values to remember. 0 means remember all (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['historyMaxLength'] = value;
        return this;
    },
    
    separator: function Ext_ux_Andrie_SelectConfig$separator(value) {
        /// <summary>
        /// Separator to use for the values passed to setValue (defaults to comma)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['separator'] = value;
        return this;
    },
    
    displaySeparator: function Ext_ux_Andrie_SelectConfig$displaySeparator(value) {
        /// <summary>
        /// Separator to use for displaying the values (defaults to comma)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['displaySeparator'] = value;
        return this;
    },
    
    transform: function Ext_ux_Andrie_SelectConfig$transform(value) {
        /// <summary>
        /// The id, DOM node or element of an existing HTML SELECT to convert to a ComboBox. Note that if you specify this and the combo is going to be in a {@link Ext.form.BasicForm} or {@link Ext.form.FormPanel}, you must also set {@link #lazyRender} = true.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['transform'] = value;
        return this;
    },
    
    lazyRender: function Ext_ux_Andrie_SelectConfig$lazyRender(value) {
        /// <summary>
        /// True to prevent the ComboBox from rendering until requested (should always be used when rendering into an Ext.Editor, defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['lazyRender'] = value;
        return this;
    },
    
    autoCreate: function Ext_ux_Andrie_SelectConfig$autoCreate(value) {
        /// <summary>
        /// {Boolean/Object} A DomHelper element spec, or true for a default element spec (defaults to: {tag: "input", type: "text", size: "24", autocomplete: "off"})
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['autoCreate'] = value;
        return this;
    },
    
    store: function Ext_ux_Andrie_SelectConfig$store(value) {
        /// <summary>
        /// {Ext.data.Store/Array} The data source to which this combo is bound (defaults to undefined).  This can be any {@link Ext.data.Store} subclass, a 1-dimensional array (e.g., ['Foo','Bar']) or a 2-dimensional array (e.g., [['f','Foo'],['b','Bar']]).  Arrays will be converted to a {@link Ext.data.SimpleStore} internally. 1-dimensional arrays will automatically be expanded (each array item will be the combo value and text) and for multi-dimensional arrays, the value in index 0 of each item will be assumed to be the combo value, while the value at index 1 is assumed to be the combo text.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['store'] = value;
        return this;
    },
    
    title: function Ext_ux_Andrie_SelectConfig$title(value) {
        /// <summary>
        /// If supplied, a header element is created containing this text and added into the top of the dropdown list (defaults to undefined, with no header element)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['title'] = value;
        return this;
    },
    
    listWidth: function Ext_ux_Andrie_SelectConfig$listWidth(value) {
        /// <summary>
        /// The width in pixels of the dropdown list (defaults to the width of the ComboBox field)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['listWidth'] = value;
        return this;
    },
    
    displayField: function Ext_ux_Andrie_SelectConfig$displayField(value) {
        /// <summary>
        /// The underlying data field name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'text' if transforming a select)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['displayField'] = value;
        return this;
    },
    
    valueField: function Ext_ux_Andrie_SelectConfig$valueField(value) {
        /// <summary>
        /// The underlying data value name to bind to this ComboBox (defaults to undefined if mode = 'remote' or 'value' if transforming a select) Note: use of a valueField requires the user to make a selection in order for a value to be mapped.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['valueField'] = value;
        return this;
    },
    
    hiddenName: function Ext_ux_Andrie_SelectConfig$hiddenName(value) {
        /// <summary>
        /// If specified, a hidden form field with this name is dynamically generated to store the field's data value (defaults to the underlying DOM element's name). Required for the combo's value to automatically post during a form submission.  Note that the hidden field's id will also default to this name if {@link #hiddenId} is not specified.  The combo's id and the hidden field's ids should be different, since no two DOM nodes should share the same id, so if the combo and hidden names are the same, you should specify a unique hiddenId.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hiddenName'] = value;
        return this;
    },
    
    hiddenId: function Ext_ux_Andrie_SelectConfig$hiddenId(value) {
        /// <summary>
        /// If {@link #hiddenName} is specified, hiddenId can also be provided to give the hidden field a unique id (defaults to the hiddenName).  The hiddenId and combo {@link #id} should be different, since no two DOM nodes should share the same id.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hiddenId'] = value;
        return this;
    },
    
    listClass: function Ext_ux_Andrie_SelectConfig$listClass(value) {
        /// <summary>
        /// CSS class to apply to the dropdown list element (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['listClass'] = value;
        return this;
    },
    
    selectedClass: function Ext_ux_Andrie_SelectConfig$selectedClass(value) {
        /// <summary>
        /// CSS class to apply to the selected item in the dropdown list (defaults to 'x-combo-selected')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['selectedClass'] = value;
        return this;
    },
    
    triggerClass: function Ext_ux_Andrie_SelectConfig$triggerClass(value) {
        /// <summary>
        /// An additional CSS class used to style the trigger button.  The trigger will always get the class 'x-form-trigger' and triggerClass will be <b>appended</b> if specified (defaults to 'x-form-arrow-trigger' which displays a downward arrow icon).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['triggerClass'] = value;
        return this;
    },
    
    shadow: function Ext_ux_Andrie_SelectConfig$shadow(value) {
        /// <summary>
        /// {Boolean/String} True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['shadow'] = value;
        return this;
    },
    
    listAlign: function Ext_ux_Andrie_SelectConfig$listAlign(value) {
        /// <summary>
        /// A valid anchor position value. See {@link Ext.Element#alignTo} for details on supported anchor positions (defaults to 'tl-bl')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['listAlign'] = value;
        return this;
    },
    
    maxHeight: function Ext_ux_Andrie_SelectConfig$maxHeight(value) {
        /// <summary>
        /// The maximum height in pixels of the dropdown list before scrollbars are shown (defaults to 300)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['maxHeight'] = value;
        return this;
    },
    
    minHeight: function Ext_ux_Andrie_SelectConfig$minHeight(value) {
        /// <summary>
        /// The minimum height in pixels of the dropdown list when the list is constrained by its distance to the viewport edges (defaults to 90)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['minHeight'] = value;
        return this;
    },
    
    triggerAction: function Ext_ux_Andrie_SelectConfig$triggerAction(value) {
        /// <summary>
        /// The action to execute when the trigger field is activated.  Use 'all' to run the query specified by the allQuery config option (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['triggerAction'] = value;
        return this;
    },
    
    minChars: function Ext_ux_Andrie_SelectConfig$minChars(value) {
        /// <summary>
        /// The minimum number of characters the user must type before autocomplete and typeahead activate (defaults to 4 if remote or 0 if local, does not apply if editable = false)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['minChars'] = value;
        return this;
    },
    
    typeAhead: function Ext_ux_Andrie_SelectConfig$typeAhead(value) {
        /// <summary>
        /// True to populate and autoselect the remainder of the text being typed after a configurable delay ({@link #typeAheadDelay}) if it matches a known value (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['typeAhead'] = value;
        return this;
    },
    
    queryDelay: function Ext_ux_Andrie_SelectConfig$queryDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown list (defaults to 500 if mode = 'remote' or 10 if mode = 'local')
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['queryDelay'] = value;
        return this;
    },
    
    pageSize: function Ext_ux_Andrie_SelectConfig$pageSize(value) {
        /// <summary>
        /// If greater than 0, a paging toolbar is displayed in the footer of the dropdown list and the filter queries will execute with page start and limit parameters.  Only applies when mode = 'remote' (defaults to 0)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['pageSize'] = value;
        return this;
    },
    
    selectOnFocus: function Ext_ux_Andrie_SelectConfig$selectOnFocus(value) {
        /// <summary>
        /// True to select any existing text in the field immediately on focus.  Only applies when editable = true (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['selectOnFocus'] = value;
        return this;
    },
    
    queryParam: function Ext_ux_Andrie_SelectConfig$queryParam(value) {
        /// <summary>
        /// Name of the query as it will be passed on the querystring (defaults to 'query')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['queryParam'] = value;
        return this;
    },
    
    loadingText: function Ext_ux_Andrie_SelectConfig$loadingText(value) {
        /// <summary>
        /// The text to display in the dropdown list while data is loading.  Only applies when mode = 'remote' (defaults to 'Loading...')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['loadingText'] = value;
        return this;
    },
    
    resizable: function Ext_ux_Andrie_SelectConfig$resizable(value) {
        /// <summary>
        /// True to add a resize handle to the bottom of the dropdown list (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['resizable'] = value;
        return this;
    },
    
    handleHeight: function Ext_ux_Andrie_SelectConfig$handleHeight(value) {
        /// <summary>
        /// The height in pixels of the dropdown list resize handle if resizable = true (defaults to 8)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['handleHeight'] = value;
        return this;
    },
    
    editable: function Ext_ux_Andrie_SelectConfig$editable(value) {
        /// <summary>
        /// False to prevent the user from typing text directly into the field, just like a traditional select (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['editable'] = value;
        return this;
    },
    
    allQuery: function Ext_ux_Andrie_SelectConfig$allQuery(value) {
        /// <summary>
        /// The text query to send to the server to return all records for the list with no filtering (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['allQuery'] = value;
        return this;
    },
    
    mode: function Ext_ux_Andrie_SelectConfig$mode(value) {
        /// <summary>
        /// Set to 'local' if the ComboBox loads local data (defaults to 'remote' which loads from the server)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['mode'] = value;
        return this;
    },
    
    minListWidth: function Ext_ux_Andrie_SelectConfig$minListWidth(value) {
        /// <summary>
        /// The minimum width of the dropdown list in pixels (defaults to 70, will be ignored if listWidth has a higher value)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['minListWidth'] = value;
        return this;
    },
    
    forceSelection: function Ext_ux_Andrie_SelectConfig$forceSelection(value) {
        /// <summary>
        /// True to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text into the field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['forceSelection'] = value;
        return this;
    },
    
    typeAheadDelay: function Ext_ux_Andrie_SelectConfig$typeAheadDelay(value) {
        /// <summary>
        /// The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['typeAheadDelay'] = value;
        return this;
    },
    
    valueNotFoundText: function Ext_ux_Andrie_SelectConfig$valueNotFoundText(value) {
        /// <summary>
        /// When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be displayed as the field text if defined (defaults to undefined). If this defaut text is used, it means there is no value set and no validation will occur on this field.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['valueNotFoundText'] = value;
        return this;
    },
    
    lazyInit: function Ext_ux_Andrie_SelectConfig$lazyInit(value) {
        /// <summary>
        /// True to not initialize the list for this combo until the field is focused (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['lazyInit'] = value;
        return this;
    },
    
    tpl: function Ext_ux_Andrie_SelectConfig$tpl(value) {
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['tpl'] = value;
        return this;
    },
    
    itemSelector: function Ext_ux_Andrie_SelectConfig$itemSelector(value) {
        /// <summary>
        /// <b>This setting is required if a custom XTemplate has been specified in {@link #tpl} which assigns a class other than <pre>'x-combo-list-item'</pre> to dropdown list items</b>. A simple CSS selector (e.g. div.some-class or span:first-child) that will be used to determine what nodes the DataView which handles the dropdown display will be working with.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['itemSelector'] = value;
        return this;
    },
    
    hideTrigger: function Ext_ux_Andrie_SelectConfig$hideTrigger(value) {
        /// <summary>
        /// True to hide the trigger element and display only the base text field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hideTrigger'] = value;
        return this;
    },
    
    vtypeText: function Ext_ux_Andrie_SelectConfig$vtypeText(value) {
        /// <summary>
        /// A custom error message to display in place of the default message provided for the {@link #vtype} currently set for this field (defaults to '').  Only applies if vtype is set, else ignored.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['vtypeText'] = value;
        return this;
    },
    
    grow: function Ext_ux_Andrie_SelectConfig$grow(value) {
        /// <summary>
        /// True if this field should automatically grow and shrink to its content
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['grow'] = value;
        return this;
    },
    
    growMin: function Ext_ux_Andrie_SelectConfig$growMin(value) {
        /// <summary>
        /// The minimum width to allow when grow = true (defaults to 30)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['growMin'] = value;
        return this;
    },
    
    growMax: function Ext_ux_Andrie_SelectConfig$growMax(value) {
        /// <summary>
        /// The maximum width to allow when grow = true (defaults to 800)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['growMax'] = value;
        return this;
    },
    
    vtype: function Ext_ux_Andrie_SelectConfig$vtype(value) {
        /// <summary>
        /// A validation type name as defined in {@link Ext.form.VTypes} (defaults to null)
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['vtype'] = value;
        return this;
    },
    
    maskRe: function Ext_ux_Andrie_SelectConfig$maskRe(value) {
        /// <summary>
        /// An input mask regular expression that will be used to filter keystrokes that don't match (defaults to null)
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['maskRe'] = value;
        return this;
    },
    
    disableKeyFilter: function Ext_ux_Andrie_SelectConfig$disableKeyFilter(value) {
        /// <summary>
        /// True to disable input keystroke filtering (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['disableKeyFilter'] = value;
        return this;
    },
    
    allowBlank: function Ext_ux_Andrie_SelectConfig$allowBlank(value) {
        /// <summary>
        /// False to validate that the value length &gt; 0 (defaults to true)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['allowBlank'] = value;
        return this;
    },
    
    blankText: function Ext_ux_Andrie_SelectConfig$blankText(value) {
        /// <summary>
        /// Error text to display if the allow blank validation fails (defaults to "This field is required")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['blankText'] = value;
        return this;
    },
    
    validator: function Ext_ux_Andrie_SelectConfig$validator(value) {
        /// <summary>
        /// A custom validation function to be called during field validation (defaults to null). If available, this function will be called only after the basic validators all return true, and will be passed the current field value and expected to return boolean true if the value is valid or a string error message if invalid.
        /// </summary>
        /// <param name="value" type="Delegate">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['validator'] = value;
        return this;
    },
    
    regex: function Ext_ux_Andrie_SelectConfig$regex(value) {
        /// <summary>
        /// A JavaScript RegExp object to be tested against the field value during validation (defaults to null). If available, this regex will be evaluated only after the basic validators all return true, and will be passed the current field value.  If the test fails, the field will be marked invalid using {@link #regexText}.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['regex'] = value;
        return this;
    },
    
    regexText: function Ext_ux_Andrie_SelectConfig$regexText(value) {
        /// <summary>
        /// The error text to display if {@link #regex} is used and the test fails during validation (defaults to "")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['regexText'] = value;
        return this;
    },
    
    emptyText: function Ext_ux_Andrie_SelectConfig$emptyText(value) {
        /// <summary>
        /// The default text to display in an empty field (defaults to null).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['emptyText'] = value;
        return this;
    },
    
    emptyClass: function Ext_ux_Andrie_SelectConfig$emptyClass(value) {
        /// <summary>
        /// The CSS class to apply to an empty field to style the {@link #emptyText} (defaults to 'x-form-empty-field').  This class is automatically added and removed as needed depending on the current field value.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['emptyClass'] = value;
        return this;
    },
    
    enableKeyEvents: function Ext_ux_Andrie_SelectConfig$enableKeyEvents(value) {
        /// <summary>
        /// True to enable the proxying of key events for the HTML input field (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['enableKeyEvents'] = value;
        return this;
    },
    
    fieldLabel: function Ext_ux_Andrie_SelectConfig$fieldLabel(value) {
        /// <summary>
        /// The label text to display next to this field (defaults to '')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['fieldLabel'] = value;
        return this;
    },
    
    labelStyle: function Ext_ux_Andrie_SelectConfig$labelStyle(value) {
        /// <summary>
        /// A CSS style specification to apply directly to this field's label (defaults to the container's labelStyle value if set, or ''). For example, <code>labelStyle: 'font-weight:bold;'</code>.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['labelStyle'] = value;
        return this;
    },
    
    labelSeparator: function Ext_ux_Andrie_SelectConfig$labelSeparator(value) {
        /// <summary>
        /// The standard separator to display after the text of each form label (defaults to the value of {@link Ext.layout.FormLayout#labelSeparator}, which is a colon ':' by default).  To display no separator for this field's label specify empty string ''.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['labelSeparator'] = value;
        return this;
    },
    
    hideLabel: function Ext_ux_Andrie_SelectConfig$hideLabel(value) {
        /// <summary>
        /// True to completely hide the label element (defaults to false)
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hideLabel'] = value;
        return this;
    },
    
    clearCls: function Ext_ux_Andrie_SelectConfig$clearCls(value) {
        /// <summary>
        /// The CSS class used to provide field clearing (defaults to 'x-form-clear-left')
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['clearCls'] = value;
        return this;
    },
    
    itemCls: function Ext_ux_Andrie_SelectConfig$itemCls(value) {
        /// <summary>
        /// An additional CSS class to apply to the wrapper's form item element of this field (defaults to the container's itemCls value if set, or '').  Since it is applied to the item wrapper, it allows you to write standard CSS rules that can apply to the field, the label (if specified) or any other element within the markup for the field. NOTE: this will not have any effect on fields that are not part of a form. Example use: <pre><code> // Apply a style to the field's label: &lt;style&gt; .required .x-form-item-label {font-weight:bold;color:red;} &lt;/style&gt; new Ext.FormPanel({ height: 100, renderTo: document.body, items: [{ xtype: 'textfield', fieldLabel: 'Name', itemCls: 'required' //this label will be styled },{ xtype: 'textfield', fieldLabel: 'Favorite Color' }] }); </code></pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['itemCls'] = value;
        return this;
    },
    
    inputType: function Ext_ux_Andrie_SelectConfig$inputType(value) {
        /// <summary>
        /// The type attribute for input fields -- e.g. radio, text, etc. (defaults to "text"). The types "file" and "password" must be used to render those field types currently -- there are no separate Ext components for those.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['inputType'] = value;
        return this;
    },
    
    tabIndex: function Ext_ux_Andrie_SelectConfig$tabIndex(value) {
        /// <summary>
        /// The tabIndex for this field. Note this only applies to fields that are rendered, not those which are built via applyTo (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['tabIndex'] = value;
        return this;
    },
    
    value: function Ext_ux_Andrie_SelectConfig$value(value) {
        /// <summary>
        /// A value to initialize this field with (defaults to undefined).
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['value'] = value;
        return this;
    },
    
    name: function Ext_ux_Andrie_SelectConfig$name(value) {
        /// <summary>
        /// The field's HTML name attribute (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['name'] = value;
        return this;
    },
    
    cls: function Ext_ux_Andrie_SelectConfig$cls(value) {
        /// <summary>
        /// A custom CSS class to apply to the field's underlying element (defaults to "").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['cls'] = value;
        return this;
    },
    
    invalidClass: function Ext_ux_Andrie_SelectConfig$invalidClass(value) {
        /// <summary>
        /// The CSS class to use when marking a field invalid (defaults to "x-form-invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['invalidClass'] = value;
        return this;
    },
    
    invalidText: function Ext_ux_Andrie_SelectConfig$invalidText(value) {
        /// <summary>
        /// The error text to use when marking a field invalid and no message is provided (defaults to "The value in this field is invalid")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['invalidText'] = value;
        return this;
    },
    
    focusClass: function Ext_ux_Andrie_SelectConfig$focusClass(value) {
        /// <summary>
        /// The CSS class to use when the field receives focus (defaults to "x-form-focus")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['focusClass'] = value;
        return this;
    },
    
    validationEvent: function Ext_ux_Andrie_SelectConfig$validationEvent(value) {
        /// <summary>
        /// {String/Boolean} The event that should initiate field validation. Set to false to disable automatic validation (defaults to "keyup").
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['validationEvent'] = value;
        return this;
    },
    
    validateOnBlur: function Ext_ux_Andrie_SelectConfig$validateOnBlur(value) {
        /// <summary>
        /// Whether the field should validate when it loses focus (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['validateOnBlur'] = value;
        return this;
    },
    
    validationDelay: function Ext_ux_Andrie_SelectConfig$validationDelay(value) {
        /// <summary>
        /// The length of time in milliseconds after user input begins until validation is initiated (defaults to 250)
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['validationDelay'] = value;
        return this;
    },
    
    fieldClass: function Ext_ux_Andrie_SelectConfig$fieldClass(value) {
        /// <summary>
        /// The default CSS class for the field (defaults to "x-form-field")
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['fieldClass'] = value;
        return this;
    },
    
    msgTarget: function Ext_ux_Andrie_SelectConfig$msgTarget(value) {
        /// <summary>
        /// The location where error text should display.  Should be one of the following values (defaults to 'qtip'): <pre> Value         Description -----------   ---------------------------------------------------------------------- qtip          Display a quick tip when the user hovers over the field title         Display a default browser title attribute popup under         Add a block div beneath the field containing the error text side          Add an error icon to the right of the field with a popup on hover [element id]  Add the error text directly to the innerHTML of the specified element </pre>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['msgTarget'] = value;
        return this;
    },
    
    msgFx: function Ext_ux_Andrie_SelectConfig$msgFx(value) {
        /// <summary>
        /// <b>Experimental</b> The effect used when displaying a validation message under the field (defaults to 'normal').
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['msgFx'] = value;
        return this;
    },
    
    readOnly: function Ext_ux_Andrie_SelectConfig$readOnly(value) {
        /// <summary>
        /// True to mark the field as readOnly in HTML (defaults to false) -- Note: this only sets the element's readOnly DOM attribute.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['readOnly'] = value;
        return this;
    },
    
    disabled: function Ext_ux_Andrie_SelectConfig$disabled(value) {
        /// <summary>
        /// True to disable the field (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['disabled'] = value;
        return this;
    },
    
    x: function Ext_ux_Andrie_SelectConfig$x(value) {
        /// <summary>
        /// The local x (left) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['x'] = value;
        return this;
    },
    
    y: function Ext_ux_Andrie_SelectConfig$y(value) {
        /// <summary>
        /// The local y (top) coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['y'] = value;
        return this;
    },
    
    pageX: function Ext_ux_Andrie_SelectConfig$pageX(value) {
        /// <summary>
        /// The page level x coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['pageX'] = value;
        return this;
    },
    
    pageY: function Ext_ux_Andrie_SelectConfig$pageY(value) {
        /// <summary>
        /// The page level y coordinate for this component if contained within a positioning container.
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['pageY'] = value;
        return this;
    },
    
    height: function Ext_ux_Andrie_SelectConfig$height(value) {
        /// <summary>
        /// The height of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['height'] = value;
        return this;
    },
    
    width: function Ext_ux_Andrie_SelectConfig$width(value) {
        /// <summary>
        /// The width of this component in pixels (defaults to auto).
        /// </summary>
        /// <param name="value" type="Number">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['width'] = value;
        return this;
    },
    
    autoHeight: function Ext_ux_Andrie_SelectConfig$autoHeight(value) {
        /// <summary>
        /// True to use height:'auto', false to use fixed height. Note: although many components inherit this config option, not all will function as expected with a height of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['autoHeight'] = value;
        return this;
    },
    
    autoWidth: function Ext_ux_Andrie_SelectConfig$autoWidth(value) {
        /// <summary>
        /// True to use width:'auto', false to use fixed width. Note: although many components inherit this config option, not all will function as expected with a width of 'auto'. (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['autoWidth'] = value;
        return this;
    },
    
    xtype: function Ext_ux_Andrie_SelectConfig$xtype(value) {
        /// <summary>
        /// The registered xtype to create. This config option is not used when passing a config object into a constructor. This config option is used only when lazy instantiation is being used, and a child item of a Container is being specified not as a fully instantiated Component, but as a Component config object. The xtype will be looked up at render time up to determine what type of child Component to create.
        /// The predefined xtypes are listed at the top of this document.
        /// If you subclass Components to create your own Components, you may register them using Ext.ComponentMgr.registerType in order to be able to take advantage of lazy instantiation and rendering.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['xtype'] = value;
        return this;
    },
    
    id: function Ext_ux_Andrie_SelectConfig$id(value) {
        /// <summary>
        /// The unique id of this component (defaults to an auto-assigned id).
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['id'] = value;
        return this;
    },
    
    autoEl: function Ext_ux_Andrie_SelectConfig$autoEl(value) {
        /// <summary>
        /// {String/Object}  A tag name or DomHelper spec to create an element with. This is intended to create shorthand utility components inline via JSON. It should not be used for higher level components which already create their own elements. Example usage: <pre><code> {xtype:'box', autoEl: 'div', cls:'my-class'} {xtype:'box', autoEl: {tag:'blockquote', html:'autoEl is cool!'}} // with DomHelper </code></pre>
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['autoEl'] = value;
        return this;
    },
    
    overCls: function Ext_ux_Andrie_SelectConfig$overCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and removed when the mouse moves out. (defaults to '').  This can be useful for adding customized "active" or "hover" styles to the component or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['overCls'] = value;
        return this;
    },
    
    style: function Ext_ux_Andrie_SelectConfig$style(value) {
        /// <summary>
        /// A custom style specification to be applied to this component's Element.  Should be a valid argument to {@link Ext.Element#applyStyles}.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['style'] = value;
        return this;
    },
    
    ctCls: function Ext_ux_Andrie_SelectConfig$ctCls(value) {
        /// <summary>
        /// An optional extra CSS class that will be added to this component's container (defaults to '').  This can be useful for adding customized styles to the container or any of its children using standard CSS rules.
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['ctCls'] = value;
        return this;
    },
    
    plugins: function Ext_ux_Andrie_SelectConfig$plugins(value) {
        /// <summary>
        /// {Object/Array}  An object or array of objects that will provide custom functionality for this component.  The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself.  Each plugin can then call methods or respond to events on the component as needed to provide its functionality.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['plugins'] = value;
        return this;
    },
    
    applyTo: function Ext_ux_Andrie_SelectConfig$applyTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in the document that specifies some structural markup for this component.  When applyTo is used, constituent parts of the component can also be specified by id or CSS class name within the main element, and the component being created may attempt to create its subcomponents from that markup if applicable. Using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the component's container.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['applyTo'] = value;
        return this;
    },
    
    renderTo: function Ext_ux_Andrie_SelectConfig$renderTo(value) {
        /// <summary>
        /// The id of the node, a DOM node or an existing Element that will be the container to render this component into. Using this config, a call to render() is not required.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['renderTo'] = value;
        return this;
    },
    
    stateful: function Ext_ux_Andrie_SelectConfig$stateful(value) {
        /// <summary>
        /// A flag which causes the Component to attempt to restore the state of internal properties from a saved state on startup.<p> For state saving to work, the state manager's provider must have been set to an implementation of {@link Ext.state.Provider} which overrides the {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} methods to save and recall name/value pairs. A built-in implementation, {@link Ext.state.CookieProvider} is available.</p><p>To set the state provider for the current page:</p><pre><code> Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); </code></pre><p>Components attempt to save state when one of the events listed in the {@link #stateEvents} configuration fires.</p><p>You can perform extra processing on state save and restore by attaching handlers to the {@link #beforestaterestore}, {@link staterestore}, {@link beforestatesave} and {@link statesave} events</p>
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['stateful'] = value;
        return this;
    },
    
    stateId: function Ext_ux_Andrie_SelectConfig$stateId(value) {
        /// <summary>
        /// The unique id for this component to use for state management purposes (defaults to the component id). <p>See {@link #stateful} for an explanation of saving and restoring Component state.</p>
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['stateId'] = value;
        return this;
    },
    
    disabledClass: function Ext_ux_Andrie_SelectConfig$disabledClass(value) {
        /// <summary>
        /// CSS class added to the component when it is disabled (defaults to "x-item-disabled").
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['disabledClass'] = value;
        return this;
    },
    
    allowDomMove: function Ext_ux_Andrie_SelectConfig$allowDomMove(value) {
        /// <summary>
        /// Whether the component can move the Dom node when rendering (defaults to true).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['allowDomMove'] = value;
        return this;
    },
    
    autoShow: function Ext_ux_Andrie_SelectConfig$autoShow(value) {
        /// <summary>
        /// True if the component should check for hidden classes (e.g. 'x-hidden' or 'x-hide-display') and remove them on render (defaults to false).
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['autoShow'] = value;
        return this;
    },
    
    hideMode: function Ext_ux_Andrie_SelectConfig$hideMode(value) {
        /// <summary>
        /// How this component should hidden. Supported values are "visibility" (css visibility), "offsets" (negative offset position) and "display" (css display) - defaults to "display".
        /// </summary>
        /// <param name="value" type="String">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hideMode'] = value;
        return this;
    },
    
    hideParent: function Ext_ux_Andrie_SelectConfig$hideParent(value) {
        /// <summary>
        /// True to hide and show the component's container when hide/show is called on the component, false to hide and show the component itself (defaults to false).  For example, this can be used as a shortcut for a hide button on a window by setting hide:true on the button when adding it to its parent container.
        /// </summary>
        /// <param name="value" type="Boolean">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['hideParent'] = value;
        return this;
    },
    
    listeners: function Ext_ux_Andrie_SelectConfig$listeners(value) {
        /// <summary>
        /// A config object containing one or more event handlers to be added to this object during initialization.  This should be a valid listeners config object as specified in the {@link #addListener} example for attaching multiple handlers at once.
        /// </summary>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o['listeners'] = value;
        return this;
    },
    
    custom: function Ext_ux_Andrie_SelectConfig$custom(key, value) {
        /// <summary>
        /// Allows you to add custom config options
        /// </summary>
        /// <param name="key" type="String">
        /// </param>
        /// <param name="value" type="Object">
        /// </param>
        /// <returns type="Ext.ux.Andrie.SelectConfig"></returns>
        this.o[key] = value;
        return this;
    },
    
    toDictionary: function Ext_ux_Andrie_SelectConfig$toDictionary() {
        /// <returns type="Object"></returns>
        return this.o;
    }
}


Ext.ActionConfig.createClass('Ext.ActionConfig');
Ext.AjaxConfig.createClass('Ext.AjaxConfig');
Ext.BoxComponentConfig.createClass('Ext.BoxComponentConfig');
Ext.BoxComponentEvents.createClass('Ext.BoxComponentEvents');
Ext.ButtonConfig.createClass('Ext.ButtonConfig');
Ext.ButtonEvents.createClass('Ext.ButtonEvents');
Ext.ColorPaletteConfig.createClass('Ext.ColorPaletteConfig');
Ext.ColorPaletteEvents.createClass('Ext.ColorPaletteEvents');
Ext.ComponentConfig.createClass('Ext.ComponentConfig');
Ext.ComponentEvents.createClass('Ext.ComponentEvents');
Ext.ComponentMgrConfig.createClass('Ext.ComponentMgrConfig');
Ext.CompositeElementConfig.createClass('Ext.CompositeElementConfig');
Ext.CompositeElementLiteConfig.createClass('Ext.CompositeElementLiteConfig');
Ext.ContainerConfig.createClass('Ext.ContainerConfig');
Ext.ContainerEvents.createClass('Ext.ContainerEvents');
Ext.CycleButtonConfig.createClass('Ext.CycleButtonConfig');
Ext.CycleButtonEvents.createClass('Ext.CycleButtonEvents');
Ext.DataViewConfig.createClass('Ext.DataViewConfig');
Ext.DataViewEvents.createClass('Ext.DataViewEvents');
Ext.DatePickerConfig.createClass('Ext.DatePickerConfig');
Ext.DatePickerEvents.createClass('Ext.DatePickerEvents');
Ext.DomHelperConfig.createClass('Ext.DomHelperConfig');
Ext.DomQueryConfig.createClass('Ext.DomQueryConfig');
Ext.EditorConfig.createClass('Ext.EditorConfig');
Ext.EditorEvents.createClass('Ext.EditorEvents');
Ext.ElementConfig.createClass('Ext.ElementConfig');
Ext.EventManagerConfig.createClass('Ext.EventManagerConfig');
Ext.EventObjectConfig.createClass('Ext.EventObjectConfig');
Ext.ExtConfig.createClass('Ext.ExtConfig');
Ext.FxConfig.createClass('Ext.FxConfig');
Ext.KeyMapConfig.createClass('Ext.KeyMapConfig');
Ext.KeyNavConfig.createClass('Ext.KeyNavConfig');
Ext.LayerConfig.createClass('Ext.LayerConfig');
Ext.LoadMaskConfig.createClass('Ext.LoadMaskConfig');
Ext.MessageBoxConfig.createClass('Ext.MessageBoxConfig');
Ext.PagingToolbarConfig.createClass('Ext.PagingToolbarConfig');
Ext.PanelConfig.createClass('Ext.PanelConfig');
Ext.PanelEvents.createClass('Ext.PanelEvents');
Ext.ProgressBarConfig.createClass('Ext.ProgressBarConfig');
Ext.ProgressBarEvents.createClass('Ext.ProgressBarEvents');
Ext.QuickTipConfig.createClass('Ext.QuickTipConfig');
Ext.QuickTipsConfig.createClass('Ext.QuickTipsConfig');
Ext.ResizableConfig.createClass('Ext.ResizableConfig');
Ext.ResizableEvents.createClass('Ext.ResizableEvents');
Ext.ShadowConfig.createClass('Ext.ShadowConfig');
Ext.SliderConfig.createClass('Ext.SliderConfig');
Ext.SliderEvents.createClass('Ext.SliderEvents');
Ext.SplitBarConfig.createClass('Ext.SplitBarConfig');
Ext.SplitBarEvents.createClass('Ext.SplitBarEvents');
Ext.SplitButtonConfig.createClass('Ext.SplitButtonConfig');
Ext.SplitButtonEvents.createClass('Ext.SplitButtonEvents');
Ext.StatusBarConfig.createClass('Ext.StatusBarConfig');
Ext.StoreMgrConfig.createClass('Ext.StoreMgrConfig');
Ext.TabPanelConfig.createClass('Ext.TabPanelConfig');
Ext.TabPanelEvents.createClass('Ext.TabPanelEvents');
Ext.TaskMgrConfig.createClass('Ext.TaskMgrConfig');
Ext.TemplateConfig.createClass('Ext.TemplateConfig');
Ext.TipConfig.createClass('Ext.TipConfig');
Ext.ToolbarConfig.createClass('Ext.ToolbarConfig');
Ext.ToolTipConfig.createClass('Ext.ToolTipConfig');
Ext.UpdaterConfig.createClass('Ext.UpdaterConfig');
Ext.UpdaterEvents.createClass('Ext.UpdaterEvents');
Ext.ViewportConfig.createClass('Ext.ViewportConfig');
Ext.WindowConfig.createClass('Ext.WindowConfig');
Ext.WindowEvents.createClass('Ext.WindowEvents');
Ext.WindowGroupConfig.createClass('Ext.WindowGroupConfig');
Ext.WindowMgrConfig.createClass('Ext.WindowMgrConfig');
Ext.XTemplateConfig.createClass('Ext.XTemplateConfig');
Ext.data.ArrayReaderConfig.createClass('Ext.data.ArrayReaderConfig');
Ext.data.ConnectionConfig.createClass('Ext.data.ConnectionConfig');
Ext.data.ConnectionEvents.createClass('Ext.data.ConnectionEvents');
Ext.data.DataProxyConfig.createClass('Ext.data.DataProxyConfig');
Ext.data.DataProxyEvents.createClass('Ext.data.DataProxyEvents');
Ext.data.DataReaderConfig.createClass('Ext.data.DataReaderConfig');
Ext.data.GroupingStoreConfig.createClass('Ext.data.GroupingStoreConfig');
Ext.data.HttpProxyConfig.createClass('Ext.data.HttpProxyConfig');
Ext.data.HttpProxyEvents.createClass('Ext.data.HttpProxyEvents');
Ext.data.JsonReaderConfig.createClass('Ext.data.JsonReaderConfig');
Ext.data.JsonStoreConfig.createClass('Ext.data.JsonStoreConfig');
Ext.data.MemoryProxyConfig.createClass('Ext.data.MemoryProxyConfig');
Ext.data.MemoryProxyEvents.createClass('Ext.data.MemoryProxyEvents');
Ext.data.NodeConfig.createClass('Ext.data.NodeConfig');
Ext.data.NodeEvents.createClass('Ext.data.NodeEvents');
Ext.data.RecordConfig.createClass('Ext.data.RecordConfig');
Ext.data.ScriptTagProxyConfig.createClass('Ext.data.ScriptTagProxyConfig');
Ext.data.ScriptTagProxyEvents.createClass('Ext.data.ScriptTagProxyEvents');
Ext.data.SimpleStoreConfig.createClass('Ext.data.SimpleStoreConfig');
Ext.data.SortTypesConfig.createClass('Ext.data.SortTypesConfig');
Ext.data.StoreConfig.createClass('Ext.data.StoreConfig');
Ext.data.StoreEvents.createClass('Ext.data.StoreEvents');
Ext.data.TreeConfig.createClass('Ext.data.TreeConfig');
Ext.data.TreeEvents.createClass('Ext.data.TreeEvents');
Ext.data.XmlReaderConfig.createClass('Ext.data.XmlReaderConfig');
Ext.dd.DDConfig.createClass('Ext.dd.DDConfig');
Ext.dd.DDProxyConfig.createClass('Ext.dd.DDProxyConfig');
Ext.dd.DDTargetConfig.createClass('Ext.dd.DDTargetConfig');
Ext.dd.DragDropConfig.createClass('Ext.dd.DragDropConfig');
Ext.dd.DragDropMgrConfig.createClass('Ext.dd.DragDropMgrConfig');
Ext.dd.DragSourceConfig.createClass('Ext.dd.DragSourceConfig');
Ext.dd.DragZoneConfig.createClass('Ext.dd.DragZoneConfig');
Ext.dd.DropTargetConfig.createClass('Ext.dd.DropTargetConfig');
Ext.dd.DropZoneConfig.createClass('Ext.dd.DropZoneConfig');
Ext.dd.RegistryConfig.createClass('Ext.dd.RegistryConfig');
Ext.dd.ScrollManagerConfig.createClass('Ext.dd.ScrollManagerConfig');
Ext.dd.StatusProxyConfig.createClass('Ext.dd.StatusProxyConfig');
Ext.form.ActionConfig.createClass('Ext.form.ActionConfig');
Ext.form.BasicFormConfig.createClass('Ext.form.BasicFormConfig');
Ext.form.BasicFormEvents.createClass('Ext.form.BasicFormEvents');
Ext.form.CheckboxConfig.createClass('Ext.form.CheckboxConfig');
Ext.form.CheckboxEvents.createClass('Ext.form.CheckboxEvents');
Ext.form.ComboBoxConfig.createClass('Ext.form.ComboBoxConfig');
Ext.form.ComboBoxEvents.createClass('Ext.form.ComboBoxEvents');
Ext.form.DateFieldConfig.createClass('Ext.form.DateFieldConfig');
Ext.form.FieldConfig.createClass('Ext.form.FieldConfig');
Ext.form.FieldEvents.createClass('Ext.form.FieldEvents');
Ext.form.FieldSetConfig.createClass('Ext.form.FieldSetConfig');
Ext.form.FormPanelConfig.createClass('Ext.form.FormPanelConfig');
Ext.form.FormPanelEvents.createClass('Ext.form.FormPanelEvents');
Ext.form.HiddenConfig.createClass('Ext.form.HiddenConfig');
Ext.form.HtmlEditorConfig.createClass('Ext.form.HtmlEditorConfig');
Ext.form.HtmlEditorEvents.createClass('Ext.form.HtmlEditorEvents');
Ext.form.LabelConfig.createClass('Ext.form.LabelConfig');
Ext.form.NumberFieldConfig.createClass('Ext.form.NumberFieldConfig');
Ext.form.RadioConfig.createClass('Ext.form.RadioConfig');
Ext.form.TextAreaConfig.createClass('Ext.form.TextAreaConfig');
Ext.form.TextFieldConfig.createClass('Ext.form.TextFieldConfig');
Ext.form.TextFieldEvents.createClass('Ext.form.TextFieldEvents');
Ext.form.TimeFieldConfig.createClass('Ext.form.TimeFieldConfig');
Ext.form.TriggerFieldConfig.createClass('Ext.form.TriggerFieldConfig');
Ext.form.VTypesConfig.createClass('Ext.form.VTypesConfig');
Ext.form.Action.LoadConfig.createClass('Ext.form.Action.LoadConfig');
Ext.form.Action.SubmitConfig.createClass('Ext.form.Action.SubmitConfig');
Ext.grid.AbstractSelectionModelConfig.createClass('Ext.grid.AbstractSelectionModelConfig');
Ext.grid.CellSelectionModelConfig.createClass('Ext.grid.CellSelectionModelConfig');
Ext.grid.CellSelectionModelEvents.createClass('Ext.grid.CellSelectionModelEvents');
Ext.grid.CheckboxSelectionModelConfig.createClass('Ext.grid.CheckboxSelectionModelConfig');
Ext.grid.ColumnModelConfig.createClass('Ext.grid.ColumnModelConfig');
Ext.grid.ColumnModelEvents.createClass('Ext.grid.ColumnModelEvents');
Ext.grid.EditorGridPanelConfig.createClass('Ext.grid.EditorGridPanelConfig');
Ext.grid.EditorGridPanelEvents.createClass('Ext.grid.EditorGridPanelEvents');
Ext.grid.GridPanelConfig.createClass('Ext.grid.GridPanelConfig');
Ext.grid.GridPanelEvents.createClass('Ext.grid.GridPanelEvents');
Ext.grid.GridViewConfig.createClass('Ext.grid.GridViewConfig');
Ext.grid.GridViewEvents.createClass('Ext.grid.GridViewEvents');
Ext.grid.GroupingViewConfig.createClass('Ext.grid.GroupingViewConfig');
Ext.grid.PropertyColumnModelConfig.createClass('Ext.grid.PropertyColumnModelConfig');
Ext.grid.PropertyGridConfig.createClass('Ext.grid.PropertyGridConfig');
Ext.grid.PropertyGridEvents.createClass('Ext.grid.PropertyGridEvents');
Ext.grid.PropertyRecordConfig.createClass('Ext.grid.PropertyRecordConfig');
Ext.grid.PropertyStoreConfig.createClass('Ext.grid.PropertyStoreConfig');
Ext.grid.RowNumbererConfig.createClass('Ext.grid.RowNumbererConfig');
Ext.grid.RowSelectionModelConfig.createClass('Ext.grid.RowSelectionModelConfig');
Ext.grid.RowSelectionModelEvents.createClass('Ext.grid.RowSelectionModelEvents');
Ext.layout.AbsoluteLayoutConfig.createClass('Ext.layout.AbsoluteLayoutConfig');
Ext.layout.AccordionConfig.createClass('Ext.layout.AccordionConfig');
Ext.layout.AnchorLayoutConfig.createClass('Ext.layout.AnchorLayoutConfig');
Ext.layout.BorderLayoutConfig.createClass('Ext.layout.BorderLayoutConfig');
Ext.layout.CardLayoutConfig.createClass('Ext.layout.CardLayoutConfig');
Ext.layout.ColumnLayoutConfig.createClass('Ext.layout.ColumnLayoutConfig');
Ext.layout.ContainerLayoutConfig.createClass('Ext.layout.ContainerLayoutConfig');
Ext.layout.FitLayoutConfig.createClass('Ext.layout.FitLayoutConfig');
Ext.layout.FormLayoutConfig.createClass('Ext.layout.FormLayoutConfig');
Ext.layout.TableLayoutConfig.createClass('Ext.layout.TableLayoutConfig');
Ext.layout.BorderLayout.RegionConfig.createClass('Ext.layout.BorderLayout.RegionConfig');
Ext.layout.BorderLayout.SplitRegionConfig.createClass('Ext.layout.BorderLayout.SplitRegionConfig');
Ext.menu.AdapterConfig.createClass('Ext.menu.AdapterConfig');
Ext.menu.BaseItemConfig.createClass('Ext.menu.BaseItemConfig');
Ext.menu.BaseItemEvents.createClass('Ext.menu.BaseItemEvents');
Ext.menu.CheckItemConfig.createClass('Ext.menu.CheckItemConfig');
Ext.menu.CheckItemEvents.createClass('Ext.menu.CheckItemEvents');
Ext.menu.ColorItemConfig.createClass('Ext.menu.ColorItemConfig');
Ext.menu.ColorMenuConfig.createClass('Ext.menu.ColorMenuConfig');
Ext.menu.ColorMenuEvents.createClass('Ext.menu.ColorMenuEvents');
Ext.menu.DateItemConfig.createClass('Ext.menu.DateItemConfig');
Ext.menu.DateMenuConfig.createClass('Ext.menu.DateMenuConfig');
Ext.menu.DateMenuEvents.createClass('Ext.menu.DateMenuEvents');
Ext.menu.ItemConfig.createClass('Ext.menu.ItemConfig');
Ext.menu.MenuConfig.createClass('Ext.menu.MenuConfig');
Ext.menu.MenuEvents.createClass('Ext.menu.MenuEvents');
Ext.menu.MenuMgrConfig.createClass('Ext.menu.MenuMgrConfig');
Ext.menu.SeparatorConfig.createClass('Ext.menu.SeparatorConfig');
Ext.menu.TextItemConfig.createClass('Ext.menu.TextItemConfig');
Ext.SplitBar.AbsoluteLayoutAdapterConfig.createClass('Ext.SplitBar.AbsoluteLayoutAdapterConfig');
Ext.SplitBar.BasicLayoutAdapterConfig.createClass('Ext.SplitBar.BasicLayoutAdapterConfig');
Ext.state.CookieProviderConfig.createClass('Ext.state.CookieProviderConfig');
Ext.state.ManagerConfig.createClass('Ext.state.ManagerConfig');
Ext.state.ProviderConfig.createClass('Ext.state.ProviderConfig');
Ext.state.ProviderEvents.createClass('Ext.state.ProviderEvents');
Ext.Toolbar.ButtonConfig.createClass('Ext.Toolbar.ButtonConfig');
Ext.Toolbar.FillConfig.createClass('Ext.Toolbar.FillConfig');
Ext.Toolbar.ItemConfig.createClass('Ext.Toolbar.ItemConfig');
Ext.Toolbar.SeparatorConfig.createClass('Ext.Toolbar.SeparatorConfig');
Ext.Toolbar.SpacerConfig.createClass('Ext.Toolbar.SpacerConfig');
Ext.Toolbar.SplitButtonConfig.createClass('Ext.Toolbar.SplitButtonConfig');
Ext.Toolbar.TextItemConfig.createClass('Ext.Toolbar.TextItemConfig');
Ext.tree.AsyncTreeNodeConfig.createClass('Ext.tree.AsyncTreeNodeConfig');
Ext.tree.AsyncTreeNodeEvents.createClass('Ext.tree.AsyncTreeNodeEvents');
Ext.tree.DefaultSelectionModelConfig.createClass('Ext.tree.DefaultSelectionModelConfig');
Ext.tree.DefaultSelectionModelEvents.createClass('Ext.tree.DefaultSelectionModelEvents');
Ext.tree.MultiSelectionModelConfig.createClass('Ext.tree.MultiSelectionModelConfig');
Ext.tree.MultiSelectionModelEvents.createClass('Ext.tree.MultiSelectionModelEvents');
Ext.tree.RootTreeNodeUIConfig.createClass('Ext.tree.RootTreeNodeUIConfig');
Ext.tree.TreeDragZoneConfig.createClass('Ext.tree.TreeDragZoneConfig');
Ext.tree.TreeDropZoneConfig.createClass('Ext.tree.TreeDropZoneConfig');
Ext.tree.TreeEditorConfig.createClass('Ext.tree.TreeEditorConfig');
Ext.tree.TreeFilterConfig.createClass('Ext.tree.TreeFilterConfig');
Ext.tree.TreeLoaderConfig.createClass('Ext.tree.TreeLoaderConfig');
Ext.tree.TreeLoaderEvents.createClass('Ext.tree.TreeLoaderEvents');
Ext.tree.TreeNodeConfig.createClass('Ext.tree.TreeNodeConfig');
Ext.tree.TreeNodeEvents.createClass('Ext.tree.TreeNodeEvents');
Ext.tree.TreeNodeUIConfig.createClass('Ext.tree.TreeNodeUIConfig');
Ext.tree.TreePanelConfig.createClass('Ext.tree.TreePanelConfig');
Ext.tree.TreePanelEvents.createClass('Ext.tree.TreePanelEvents');
Ext.tree.TreeSorterConfig.createClass('Ext.tree.TreeSorterConfig');
Ext.Updater.BasicRendererConfig.createClass('Ext.Updater.BasicRendererConfig');
Ext.Updater.defaultsConfig.createClass('Ext.Updater.defaultsConfig');
Ext.util.ClickRepeaterConfig.createClass('Ext.util.ClickRepeaterConfig');
Ext.util.ClickRepeaterEvents.createClass('Ext.util.ClickRepeaterEvents');
Ext.util.CSSConfig.createClass('Ext.util.CSSConfig');
Ext.util.DelayedTaskConfig.createClass('Ext.util.DelayedTaskConfig');
Ext.util.FormatConfig.createClass('Ext.util.FormatConfig');
Ext.util.JSONConfig.createClass('Ext.util.JSONConfig');
Ext.util.MixedCollectionConfig.createClass('Ext.util.MixedCollectionConfig');
Ext.util.MixedCollectionEvents.createClass('Ext.util.MixedCollectionEvents');
Ext.util.ObservableConfig.createClass('Ext.util.ObservableConfig');
Ext.util.TaskRunnerConfig.createClass('Ext.util.TaskRunnerConfig');
Ext.util.TextMetricsConfig.createClass('Ext.util.TextMetricsConfig');
Ext.ux.Andrie.SelectConfig.createClass('Ext.ux.Andrie.SelectConfig');

// ---- Do not remove this footer ----
// Generated using Script# v0.5.0.0 (http://projects.nikhilk.net)
// -----------------------------------

// *********************************************
//      ExtSharp Adapter/Compatability Script
// *********************************************

// **** renamed classes ****
ExtClass = Ext;
Ext.UpdaterClass = Ext.Updater;
Ext.SplitBarClass = Ext.SplitBar;
Ext.ToolbarClass = Ext.Toolbar;
Ext.WindowClass = Ext.Window;
Ext.form.ActionClass = Ext.form.Action;
Ext.layout.BorderLayoutClass = Ext.layout.BorderLayout;

// **** renamed methods ****
Ext.DomQuery.is_ = Ext.DomQuery.is;
Ext.Element.is_ = Ext.Element.is;
Ext.override_ = Ext.override;
Ext.namespace_ = Ext.namespace;
Ext.dd.DragDrop.lock_ = Ext.dd.DragDrop.lock;
Ext.dd.DragDropMgr.lock_ = Ext.dd.DragDropMgr.lock;
Ext.grid.AbstractSelectionModel.lock_ = Ext.grid.AbstractSelectionModel.lock;

// **** renamed properties ****
Ext.form.Action.params_ = Ext.form.Action.params;
Ext.form.Checkbox.checked_ = Ext.form.Checkbox.checked;
Ext.grid.ColumnModel.fixed_ = Ext.grid.ColumnModel.fixed;
Ext.menu.CheckItem.checked_ = Ext.menu.CheckItem.checked;

// changes Script#'s inheritance to use Ext.extend()
// backup the existing createClass function
Type.prototype._createClass = Type.prototype.createClass;
Type.prototype.createClass = function(n,b,i) {
    // if a base type is defined then use Ext.extend()
    if(b) {
        var ct=b.prototype.ctype;
        var sp = typeof b.superclass != 'undefined';
        // if the base type is an ExtJS class
        if(sp || (ct && ct.substring(0,3)=='Ext')) {
            // ugly, I know, but i don't know any other way to accoplish this
            eval('Ext.extend(' + n + ', b, this.prototype);');
            
            // prevent Script# from copying members
            delete this.__basePrototypePending;
            
            // copied from Type.prototype.createClass
            this.__typeName = n;
            this.__class = true;
            this.__baseType = Object;
            
            return;
        }
    }
    // call the original createClass function if there isn't a baseType
    this._createClass(n,b,i);
}


// **** bug fixes ****

// Script# overwrites the String.replace() method with a different implementation
// that replaces all occurences of the text to search for instead of just the 
// first occurrence. This behavior breaks the Ext DomQuery class. Luckily Script#
// stores a backup of the original method, so I'll just revert the change back
//  - sscorlib.debug.js, line #564
String.prototype.replace = String.prototype._replace;

// Revert back to ExtJS String.format function because Date.formatCodeToRegex() will
// fail using Script#'s String.format function
String.format = function String$format(format) {
    var args = Array.prototype.slice.call(arguments, 1);
    return format.replace(/\{(\d+)\}/g, function(m, i){
        return args[i];
    });
}


